diff --git a/.gitattributes b/.gitattributes index 440bb5148c..3cb68a29e1 100644 --- a/.gitattributes +++ b/.gitattributes @@ -9,3 +9,4 @@ tools/linuxfs/desktop/** text eol=lf tools/mangoapp/mangoapp text eol=lf app/src/main/assets/desktop-removal/*.json text eol=lf app/src/main/assets/desktop-removal/*.txt text eol=lf +*.pdf binary diff --git a/.github/workflows/build-fex.yml b/.github/workflows/build-fex.yml index 85ced9cfdc..8ec3369a1a 100644 --- a/.github/workflows/build-fex.yml +++ b/.github/workflows/build-fex.yml @@ -1,4 +1,7 @@ -name: Build FEX (x86-64 Steam client experiment) +name: Build FEX (x86-64 Steam client) + +# Checks tools/fex: the same build DroidDeck-Components' build-fex.yml runs from this repository to publish FEX +# (its single `fex` release and fex.json, which the app follows). Nothing is published from here. on: push: @@ -7,16 +10,12 @@ on: - '.github/workflows/build-fex.yml' workflow_dispatch: inputs: - tag: - description: 'Release tag to publish as (e.g. fex-2609-r1); empty = artifact only' - required: false - default: '' thunks: description: 'Build the host thunks (Vulkan/GL/X11/... to the runtime arm64 libraries)' required: false default: 'false' cxxflags: - description: 'Extra CXXFLAGS for a diagnostic build (e.g. -DDEBUG_STRACE); never published with a tag' + description: 'Extra CXXFLAGS for a diagnostic build (e.g. -DDEBUG_STRACE)' required: false default: '' @@ -48,30 +47,3 @@ jobs: fex.tzst.sha256 fex-needed.txt fex-files.txt - - # Only this job can write: the build above runs third-party images and toolchains with a read-only token. - publish: - needs: build - if: github.event_name == 'workflow_dispatch' && inputs.tag != '' && inputs.cxxflags == '' && inputs.thunks == 'true' - runs-on: ubuntu-24.04 - permissions: - contents: write - steps: - - uses: actions/download-artifact@v4 - with: - name: fex - - name: Publish - env: - GH_TOKEN: ${{ github.token }} - GH_REPO: ${{ github.repository }} - TAG: ${{ inputs.tag }} - run: | - set -euo pipefail - # droiddeck-steam-x64 pins each tag's sha256 and the build is not reproducible: never rebuild over a tag. - if gh release view "$TAG" >/dev/null 2>&1; then - echo "::error::release $TAG already exists; publish under a new tag" - exit 1 - fi - gh release create "$TAG" --target "$GITHUB_SHA" --latest=false --prerelease=false --title "$TAG" --notes "FEX for the runtime (tools/fex/build-in-arch.sh); fetched by droiddeck-steam-x64. sha256 $(cut -d' ' -f1 fex.tzst.sha256)" fex.tzst fex.tzst.sha256 - # Fetched by tag by the app, never installed by users: never the repo's Latest release nor a pre-release. - gh release edit "$TAG" --latest=false --prerelease=false diff --git a/README.md b/README.md index e55303c4c7..b1b3bb7f80 100644 --- a/README.md +++ b/README.md @@ -19,6 +19,10 @@ Use Android 9 or newer on a supported Adreno device (730 or newer, or 8xx). Adre On Android 14 and newer, before Steam launches, you must turn on **Disable child process restrictions** in Developer options. If this option is not available in developer settings (Android 12 and 13 devices), first launch of Steam will present a "Fix it for me" button, which will help automate the setup process. +## Smart glasses + +Use **Setup → Smart glasses** for app-wide virtual-screen settings across DroidDeck menus, launchers, desktop sessions, and games. Supported VITURE, RayNeo, and XREAL connections provide 3DoF; Luma Ultra adds optional experimental 6DoF and stereo-assisted hand/Joy-Con tracking. Model support and SDK requirements differ: see the [smart-glasses support matrix](docs/smart-glasses-support.md) for supported devices, controls, setup, and limitations. + ## Community Join the [DroidDeck Discord](https://discord.gg/JRGAvawjsm) for help, Preview builds, and device reports. Bug reports go in its **#bug-reports** forum; attach the zip from **Share logs** (Setup, or the session drawer) so the logs come with it. diff --git a/app/build.gradle b/app/build.gradle index ac790fc394..4799d4fe46 100644 --- a/app/build.gradle +++ b/app/build.gradle @@ -12,7 +12,14 @@ if (localBuildOptionsFile.asFile.exists()) { } def pythonExecutable = project.findProperty('pythonExecutable') ?: localBuildOptions.getProperty('droiddeck.python', 'python3') -def vitureSdkDir = project.findProperty('vitureSdkDir') ?: localBuildOptions.getProperty('droiddeck.vitureSdk', '') +def vitureSdkDir = project.hasProperty('vitureSdkDir') ? project.property('vitureSdkDir') : localBuildOptions.getProperty('droiddeck.vitureSdk', '') +def uvcDir = project.hasProperty('uvcDir') ? project.property('uvcDir') : localBuildOptions.getProperty('droiddeck.uvcDir', '') +if (uvcDir) { + ['arm64-v8a/libusb.so', 'arm64-v8a/libuvc.a', 'include/libusb.h', 'include/libuvc/libuvc.h', + 'licenses/libusb-COPYING', 'licenses/libuvc-LICENSE.txt'].each { required -> + if (!new File(uvcDir, required).isFile()) throw new GradleException("Incomplete UVC build: missing ${required}") + } +} if (vitureSdkDir) { ['android/arm64-v8a/libglasses.so', 'android/arm64-v8a/libcarina_vio.so', 'android/arm64-v8a/libcloud_protocol.so', 'include/viture_glasses_provider.h', @@ -98,8 +105,8 @@ android { applicationId "com.droiddeck.launcher" minSdkVersion 26 targetSdkVersion 28 - versionCode 13 - versionName "0.4.0" + versionCode 14 + versionName "0.5.0" buildConfigField "String", "BUILD_LABEL", "\"${escapedBuildLabel}\"" buildConfigField "String", "SOURCE_COMMIT", "\"${sourceCommit}\"" buildConfigField "int", "PR_NUMBER", "${prNumber}" @@ -120,6 +127,7 @@ android { cmake { arguments '-DANDROID_STL=c++_shared' arguments "-DDROIDDECK_VITURE_SDK_DIR=${vitureSdkDir.toString().replace('\\', '/')}" + arguments "-DDROIDDECK_UVC_DIR=${uvcDir.toString().replace('\\', '/')}" } } } @@ -225,6 +233,14 @@ def stageRuntimeAssets = tasks.register('stageRuntimeAssets', Sync) { } android.sourceSets.main.assets.setSrcDirs([runtimeAssetsDir]) if (vitureSdkDir) android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('vitureAssets')) +if (uvcDir) { + def stageUvcNotices = tasks.register('stageUvcNotices', Copy) { + from(new File(uvcDir, 'licenses')) + into(layout.buildDirectory.dir('uvcAssets/licenses/uvc')) + } + tasks.named('preBuild').configure { dependsOn(stageUvcNotices) } + android.sourceSets.main.assets.srcDir(layout.buildDirectory.dir('uvcAssets')) +} tasks.named('preBuild').configure { dependsOn(stageRuntimeAssets) } def verifyRuntimeInputs = tasks.register('verifyRuntimeInputs', Exec) { @@ -266,7 +282,22 @@ def buildRustStores = tasks.register('buildRustStores', Exec) { if (!skipRust) android.sourceSets.main.jniLibs.srcDir(rustJniLibsDir) tasks.named('preBuild').configure { dependsOn(buildRustStores) } +def verifyHandModel = tasks.register('verifyHandModel') { + def models = ['hand_landmarker.task': 'fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1', + 'hand_landmarker_lite.task': '173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8'] + .collectEntries { name, hash -> [(file("src/main/assets/models/$name")): hash] } + inputs.files(models.keySet()) + doLast { + models.each { model, expected -> + def actual = java.security.MessageDigest.getInstance('SHA-256').digest(model.bytes).encodeHex().toString() + if (actual != expected) throw new GradleException("Hand Landmarker model checksum mismatch: ${model.name}") + } + } +} +tasks.named('preBuild').configure { dependsOn(verifyHandModel) } + dependencies { + implementation 'org.opencv:opencv:4.13.0' implementation 'org.khronos.openxr:openxr_loader_for_android:1.1.49' implementation 'com.github.luben:zstd-jni:1.5.7-4@aar' implementation 'org.apache.commons:commons-compress:1.27.1' @@ -285,7 +316,7 @@ dependencies { implementation 'com.termux.termux-app:terminal-view:0.118.0' implementation 'androidx.camera:camera-camera2:1.4.2' implementation 'androidx.camera:camera-lifecycle:1.4.2' - implementation('com.google.mediapipe:tasks-vision:0.10.21') { + implementation('com.google.mediapipe:tasks-vision:1.0.0') { exclude group: 'com.google.auto.value', module: 'auto-value' } diff --git a/app/src/main/AndroidManifest.xml b/app/src/main/AndroidManifest.xml index a21fea19f7..757d21bf84 100644 --- a/app/src/main/AndroidManifest.xml +++ b/app/src/main/AndroidManifest.xml @@ -44,6 +44,8 @@ android:isGame="true"> + + diff --git a/app/src/main/assets/calibration/luma-ultra-640x480.json b/app/src/main/assets/calibration/luma-ultra-640x480.json new file mode 100644 index 0000000000..8136cdeebb --- /dev/null +++ b/app/src/main/assets/calibration/luma-ultra-640x480.json @@ -0,0 +1,102 @@ +{ + "version": 1, + "identity": "luma-ultra-base-v1", + "width": 640, + "height": 480, + "fisheye": false, + "error": 1.1209395390660726, + "verified": false, + "k1": { + "rows": 3, + "cols": 3, + "data": [ + 226.0499636040297, + 0, + 321.62348950766386, + 0, + 228.36987999988767, + 242.2674105020684, + 0, + 0, + 1 + ] + }, + "d1": { + "rows": 5, + "cols": 1, + "data": [ + -0.28622915867944043, + 0.1194613930041054, + 0.007984341063494766, + -0.0008220922923559441, + -0.025579805296512992 + ] + }, + "k2": { + "rows": 3, + "cols": 3, + "data": [ + 240.3338202496282, + 0, + 320.8790079027563, + 0, + 241.14047924325277, + 260.45566640784716, + 0, + 0, + 1 + ] + }, + "d2": { + "rows": 5, + "cols": 1, + "data": [ + -0.27073208928390136, + 0.08065508519805098, + -0.001460778493930769, + -0.0003694718992635806, + -0.011452505620454932 + ] + }, + "r": { + "rows": 3, + "cols": 3, + "data": [ + 0.900501479835182, + 0.04473903344740378, + -0.43254537762047496, + -0.08255720039597626, + 0.9941919046988283, + -0.06904176485356042, + 0.4269442510181227, + 0.0978819468416306, + 0.8989648107712929 + ] + }, + "t": { + "rows": 3, + "cols": 1, + "data": [ + -0.14117171913441395, + 0.0014051874404824838, + -0.007555740272006347 + ] + }, + "cameraToHead": [ + -0.05607918, + 0.023585627, + -0.07998472, + 0.01024512, + 0.9945703, + 0.005859665, + -0.10339546 + ], + "deviceModel": "VITURE Luma Ultra", + "cameraPair": "left0-right0", + "sourceValidation": { + "exportDate": "2026-10-16", + "sourceDeviceVerified": true, + "capturedViews": 25, + "scope": "Starting geometry from one calibrated Luma Ultra; other units have not been individually validated." + } +} diff --git a/app/src/main/assets/models/hand_landmarker.provenance.json b/app/src/main/assets/models/hand_landmarker.provenance.json new file mode 100644 index 0000000000..d9dd876645 --- /dev/null +++ b/app/src/main/assets/models/hand_landmarker.provenance.json @@ -0,0 +1,9 @@ +{ + "url": "https://storage.googleapis.com/mediapipe-models/hand_landmarker/hand_landmarker/float16/1/hand_landmarker.task", + "sha256": "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1", + "bytes": 7819105, + "mediapipe": "com.google.mediapipe:tasks-vision:1.0.0", + "opencv": "org.opencv:opencv:4.13.0", + "documentation": "https://ai.google.dev/edge/mediapipe/solutions/vision/hand_landmarker", + "runtime": "Two video-mode instances; CPU default; GPU requires separate performance acceptance" +} diff --git a/app/src/main/assets/models/hand_landmarker.task b/app/src/main/assets/models/hand_landmarker.task new file mode 100644 index 0000000000..0d53faf378 Binary files /dev/null and b/app/src/main/assets/models/hand_landmarker.task differ diff --git a/app/src/main/assets/models/hand_landmarker_lite.provenance.json b/app/src/main/assets/models/hand_landmarker_lite.provenance.json new file mode 100644 index 0000000000..29bebf8d73 --- /dev/null +++ b/app/src/main/assets/models/hand_landmarker_lite.provenance.json @@ -0,0 +1,12 @@ +{ + "sha256": "173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8", + "composition": "Lite palm detector and lite hand landmarks with matching Tasks tensor metadata and associated files from the full bundle", + "palm_source": "https://storage.googleapis.com/mediapipe-assets/palm_detection_lite.tflite", + "palm_source_sha256": "e9a4aaddf90dda56a87235303cf00e4c2d3fb28725f68fd88772997dac905c18", + "landmark_source": "https://storage.googleapis.com/mediapipe-assets/hand_landmark_lite.tflite", + "landmark_source_sha256": "d7fde8ac11f8ce03f8663775bfc323f4fc9f2a38062b4f4efa142874ef5b2a48", + "metadata_source": "hand_landmarker.task", + "metadata_source_sha256": "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1", + "builder": "tools/build_hand_lite.py; mediapipe==0.10.21; deterministic ZIP_STORED bundle and embedded associated-file archives", + "runtime": "com.google.mediapipe:tasks-vision:1.0.0; CPU by default; experimental stereo hand and wrist tracking" +} diff --git a/app/src/main/assets/models/hand_landmarker_lite.task b/app/src/main/assets/models/hand_landmarker_lite.task new file mode 100644 index 0000000000..4c0ab68b42 Binary files /dev/null and b/app/src/main/assets/models/hand_landmarker_lite.task differ diff --git a/app/src/main/cpp/CMakeLists.txt b/app/src/main/cpp/CMakeLists.txt index 9aa175caee..01a0a97a2b 100644 --- a/app/src/main/cpp/CMakeLists.txt +++ b/app/src/main/cpp/CMakeLists.txt @@ -47,3 +47,15 @@ if(DROIDDECK_VITURE_SDK_DIR) target_link_directories(droiddeck_viture PRIVATE "${DROIDDECK_VITURE_SDK_DIR}/android/${ANDROID_ABI}") target_link_libraries(droiddeck_viture PRIVATE glasses log) endif() + +if(DROIDDECK_UVC_DIR) + add_library(rgb_usb SHARED IMPORTED) + set_target_properties(rgb_usb PROPERTIES IMPORTED_LOCATION "${DROIDDECK_UVC_DIR}/${ANDROID_ABI}/libusb.so") + add_library(rgb_uvc STATIC IMPORTED) + set_target_properties(rgb_uvc PROPERTIES IMPORTED_LOCATION "${DROIDDECK_UVC_DIR}/${ANDROID_ABI}/libuvc.a") + add_library(droiddeck_uvc SHARED viture/uvc_bridge.cpp) + target_compile_features(droiddeck_uvc PRIVATE cxx_std_17) + target_include_directories(droiddeck_uvc PRIVATE "${DROIDDECK_UVC_DIR}/include") + target_link_libraries(droiddeck_uvc PRIVATE rgb_uvc rgb_usb log) + target_link_options(droiddeck_uvc PRIVATE -Wl,-z,max-page-size=16384) +endif() diff --git a/app/src/main/cpp/fakeinput_steam.cpp b/app/src/main/cpp/fakeinput_steam.cpp index 71022649c6..486b72076e 100644 --- a/app/src/main/cpp/fakeinput_steam.cpp +++ b/app/src/main/cpp/fakeinput_steam.cpp @@ -75,7 +75,16 @@ static constexpr uint8_t GAMEPAD_AXIS_COUNT = 8; static constexpr uint8_t GAMEPAD_BUTTON_COUNT = 11; static constexpr uint32_t FAKE_INPUT_RING_MAGIC = 0x46494252; static constexpr uint32_t FAKE_INPUT_RING_VERSION = 2; -static constexpr uint32_t FAKE_INPUT_EVENT_SIZE = sizeof(struct input_event); +// Rings hold the 64-bit input_event layout that the arm64 writers use; 32-bit guests convert on read. +struct RingEvent { + int64_t sec; + int64_t usec; + uint16_t type; + uint16_t code; + int32_t value; +}; +static_assert(sizeof(RingEvent) == 24, "ring events must stay ABI-stable"); +static constexpr uint32_t FAKE_INPUT_EVENT_SIZE = sizeof(RingEvent); static constexpr uint32_t FAKE_INPUT_RING_CAPACITY = 4096; static constexpr unsigned int FAKE_INPUT_MAJOR = 13; static constexpr unsigned int FAKE_INPUT_EVENT_MINOR_BASE = 64; @@ -928,14 +937,13 @@ __attribute__((visibility("hidden"))) static void flush_uinput(UinputWriter &w) return; } FakeInputRingHeader *ring = w.ring; - auto *events = reinterpret_cast(reinterpret_cast(ring) + - FAKE_INPUT_RING_HEADER_SIZE); + auto *events = reinterpret_cast(reinterpret_cast(ring) + + FAKE_INPUT_RING_HEADER_SIZE); uint64_t write_seq = __atomic_load_n(&ring->write_seq, __ATOMIC_RELAXED); struct timeval now = {}; gettimeofday(&now, nullptr); - for (struct input_event ev : w.pending) { - ev.time = now; - events[write_seq % FAKE_INPUT_RING_CAPACITY] = ev; + for (const struct input_event &ev : w.pending) { + events[write_seq % FAKE_INPUT_RING_CAPACITY] = {now.tv_sec, now.tv_usec, ev.type, ev.code, ev.value}; write_seq++; if (ev.type == EV_KEY) { for (size_t i = 0; i < kSnapshotButtonCount; i++) @@ -3511,6 +3519,12 @@ EXPORT int ioctl(int fd, ioctl_request_t op, ...) { } else if (type == 0x45 && number == 0x90) { Logger::log("Hooking ioctl EVIOCGRAB for event %s\n", event); return 0; + } else if (type == 0x6A && !strncmp(event, "event", 5)) { + // Older SDL2 builds treat any JSIOCGNAME answer as a joydev node and skip EVIOCGID, then drop the pad as 0000:0000. + Logger::log("Rejecting joydev ioctl %d for event %s\n", number, event); + guard.unlock(); + errno = EINVAL; + return -1; } else if (type == 0x6A && number == 0x1) { Logger::log("Hooking ioctl JSIOCGVERSION for event %s\n", event); int version = JS_VERSION; @@ -3573,7 +3587,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { } auto handle = controller->second; FakeController &fake = *handle; - if (count < FAKE_INPUT_EVENT_SIZE) { + if (count < sizeof(struct input_event)) { errno = EINVAL; return -1; } @@ -3591,7 +3605,7 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { return -1; } for (int attempt = 0; attempt < 8; ++attempt) { - size_t requested = count / FAKE_INPUT_EVENT_SIZE; + size_t requested = count / sizeof(struct input_event); if (fake.keyframe_remaining == 0) { SnapshotState snap; if (!read_snapshot(fake.ring, snap)) break; @@ -3610,17 +3624,22 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { FAKE_INPUT_RING_HEADER_SIZE; for (size_t i = 0; i < events; ++i) { size_t index = (fake.read_seq + i) % FAKE_INPUT_RING_CAPACITY; - struct input_event ev; - memcpy(&ev, ring_events + index * FAKE_INPUT_EVENT_SIZE, FAKE_INPUT_EVENT_SIZE); + RingEvent stored; + memcpy(&stored, ring_events + index * FAKE_INPUT_EVENT_SIZE, FAKE_INPUT_EVENT_SIZE); + struct input_event ev = {}; + ev.time.tv_sec = stored.sec; + ev.time.tv_usec = stored.usec; + ev.type = stored.type; + ev.code = stored.code; + ev.value = stored.value; if (ev.type == EV_ABS) ev.code = presented_abs_code(fake, ev.code); - memcpy(static_cast(buf) + i * FAKE_INPUT_EVENT_SIZE, &ev, - FAKE_INPUT_EVENT_SIZE); + memcpy(static_cast(buf) + i * sizeof(ev), &ev, sizeof(ev)); } __atomic_thread_fence(__ATOMIC_ACQUIRE); if (snap.sequence != __atomic_load_n(&fake.ring->snapshot_seq, __ATOMIC_RELAXED)) continue; fake.read_seq += events; - return static_cast(events * FAKE_INPUT_EVENT_SIZE); + return static_cast(events * sizeof(struct input_event)); } } @@ -3635,11 +3654,10 @@ EXPORT ssize_t read(int fd, void *buf, size_t count) { ev.code = kNeutralEvents[index].code; ev.value = keyframe_value(fake, ev.type, ev.code); if (ev.type == EV_ABS) ev.code = presented_abs_code(fake, ev.code); - memcpy(static_cast(buf) + i * FAKE_INPUT_EVENT_SIZE, - &ev, FAKE_INPUT_EVENT_SIZE); + memcpy(static_cast(buf) + i * sizeof(ev), &ev, sizeof(ev)); --fake.keyframe_remaining; } - return static_cast(events * FAKE_INPUT_EVENT_SIZE); + return static_cast(events * sizeof(struct input_event)); } if (nonblock) { errno = EAGAIN; diff --git a/app/src/main/cpp/viture/mjpeg_payload.h b/app/src/main/cpp/viture/mjpeg_payload.h new file mode 100644 index 0000000000..a451a4eeea --- /dev/null +++ b/app/src/main/cpp/viture/mjpeg_payload.h @@ -0,0 +1,11 @@ +#pragma once +#include +#include + +inline std::size_t mjpeg_payload_size(const uint8_t* bytes, std::size_t size) { + if (!bytes || size < 4 || size > 4*1024*1024 || bytes[0] != 0xff || bytes[1] != 0xd8) return 0; + std::size_t end = size; + // Luma Ultra UVC frames can pad the JPEG to an eight-byte boundary with zeros. + while (end > 4 && size-end < 7 && bytes[end-1] == 0) --end; + return bytes[end-2] == 0xff && bytes[end-1] == 0xd9 ? end : 0; +} diff --git a/app/src/main/cpp/viture/sdk_bridge.cpp b/app/src/main/cpp/viture/sdk_bridge.cpp index a0be4f88d7..053c283358 100644 --- a/app/src/main/cpp/viture/sdk_bridge.cpp +++ b/app/src/main/cpp/viture/sdk_bridge.cpp @@ -2,17 +2,32 @@ #include #include #include +#include +#include +#include +#include #include #include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include "viture_glasses_provider.h" #include "viture_device.h" #include "viture_device_carina.h" +#include "viture_camera_provider.h" #include "viture_protocol_public.h" #include "viture_result.h" #include "viture_version.h" #include "display_modes.h" +#include "stereo_frame_gate.h" namespace { // SDK callbacks have no user-data parameter. Only one provider may exist at a time. @@ -59,6 +74,61 @@ void clear_pose(bool accept) { latest_time = 0; } +int64_t monotonic_ns() { + timespec ts{}; clock_gettime(CLOCK_MONOTONIC, &ts); + return int64_t(ts.tv_sec) * 1000000000LL + ts.tv_nsec; +} +struct CameraPose { double time; std::array pose; }; +std::mutex camera_mutex; +std::deque camera_poses; +std::vector camera_left, camera_right; +bool camera_accepting = false, camera_wanted = false; +int camera_width = 0, camera_height = 0; +uint64_t camera_sequence = 0, camera_consumed = 0; +StereoFrameGate camera_gate; +uint64_t camera_input_sequence = 0; +int64_t camera_receipt = 0; +int64_t camera_pose_receipt = 0; +double camera_source = 0; +const CameraPose *matched_camera_pose(double source) { + const CameraPose *best = nullptr; + double distance = 0.005; + for (const auto &p : camera_poses) if (std::abs(p.time-source) < distance) { + best = &p; distance = std::abs(p.time-source); + } + return best; +} +void on_carina_pose(float *pose, double stamp) { + if (!pose || !std::isfinite(stamp)) return; + std::lock_guard lock(camera_mutex); + if (!camera_accepting) return; + camera_pose_receipt = monotonic_ns(); + CameraPose p{stamp, {}}; std::copy_n(pose, 7, p.pose.begin()); + camera_poses.push_back(p); + while (camera_poses.size() > 64) camera_poses.pop_front(); +} +void on_camera(char *left, char *right, char *, char *, double stamp, int width, int height) { + if (!left || !right || width <= 0 || height <= 0 || width > 2048 || height > 2048 || !std::isfinite(stamp)) return; + const auto received = monotonic_ns(); + std::lock_guard lock(camera_mutex); + if (!camera_accepting || !camera_wanted) return; + if (!camera_gate.Accept(stamp)) return; + const size_t size = size_t(width) * height; + camera_left.resize(size); camera_right.resize(size); + memcpy(camera_left.data(), left, size); memcpy(camera_right.data(), right, size); + camera_width = width; camera_height = height; camera_source = stamp; camera_receipt = received; + camera_input_sequence = camera_gate.received; + ++camera_sequence; +} +void clear_camera(bool enabled) { + std::lock_guard lock(camera_mutex); + camera_accepting = enabled; camera_wanted = false; + camera_poses.clear(); camera_left.clear(); camera_right.clear(); + camera_sequence = camera_consumed = 0; + camera_gate = {}; camera_input_sequence = 0; + camera_pose_receipt = 0; +} + struct Session { XRDeviceProviderHandle device = nullptr; int pid = 0; @@ -72,6 +142,7 @@ struct Session { int saved_dof = -1; int64_t consumed_time = 0; jlong token = 0; + int spatial_status = 1; }; std::unique_ptr session; jlong next_token = 0; @@ -127,6 +198,7 @@ int tracking(Session& s, bool enabled) { } void destroy(Session& s) { + clear_camera(false); clear_pose(false); clear_state(false); if (s.device) { @@ -205,7 +277,7 @@ extern "C" JNIEXPORT jstring JNICALL JNI_METHOD(nativeMarketName)(JNIEnv* env, j return env->NewStringUTF(name); } -extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeOpen)(JNIEnv* env, jobject, jint pid, jint fd, jstring cache) { +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeOpen)(JNIEnv* env, jobject, jint pid, jint fd, jstring cache, jboolean spatial) { std::lock_guard lock(api_mutex); if (session || fd < 0 || !cache || !xr_device_provider_is_product_id_valid(pid)) return 0; auto s = std::make_unique(); @@ -221,7 +293,7 @@ extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeOpen)(JNIEnv* env, jobject, } if (rc == 0) { rc = s->type == XR_DEVICE_TYPE_VITURE_CARINA ? - xr_device_provider_set_dof_type_carina(s->device, 0) : + xr_device_provider_set_dof_type_carina(s->device, spatial ? 1 : 0) : xr_device_provider_register_imu_pose_callback(s->device, on_pose); } if (rc == 0) { @@ -231,6 +303,10 @@ extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeOpen)(JNIEnv* env, jobject, env->ReleaseStringUTFChars(cache, directory); s->initialized = rc == 0; } + if (rc == 0 && s->type == XR_DEVICE_TYPE_VITURE_CARINA && spatial) { + clear_camera(true); + rc = xr_device_provider_register_callbacks_carina(s->device, on_carina_pose, nullptr, nullptr, on_camera); + } if (rc == 0) { rc = xr_device_provider_start(s->device); s->started = rc == 0; @@ -306,3 +382,175 @@ extern "C" JNIEXPORT void JNICALL JNI_METHOD(nativeClose)(JNIEnv*, jobject, jlon std::lock_guard lock(api_mutex); if (session && session->token == token) { destroy(*session); session.reset(); } } + +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeSpatialPose)(JNIEnv* env, jobject, jlong token, + jfloatArray output, jintArray state) { + std::lock_guard lock(api_mutex); + if (!session || session->token != token || !session->tracking || session->type != XR_DEVICE_TYPE_VITURE_CARINA || + !output || !state || env->GetArrayLength(output) != 7 || env->GetArrayLength(state) != 1) return 0; + float pose[7]{}; int status = 1; + int rc = xr_device_provider_get_gl_pose_carina(session->device, pose, 0.0, &status); + session->spatial_status = rc == 0 ? status : rc; + jint valid = rc == 0 ? status : rc; + if (valid == 0) { + std::lock_guard lock(camera_mutex); + if (monotonic_ns()-camera_pose_receipt > 100000000LL) valid = 1; + } + env->SetIntArrayRegion(state, 0, 1, &valid); + env->SetFloatArrayRegion(output, 0, 7, pose); + return monotonic_ns(); +} +extern "C" JNIEXPORT void JNICALL JNI_METHOD(nativeCapture)(JNIEnv*, jobject, jlong token, jboolean wanted, jint ratePermille) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return; + std::lock_guard lock(camera_mutex); + camera_wanted = wanted; + camera_gate.SetRatePermille(wanted ? ratePermille : 1000); + if (!wanted) camera_consumed = camera_sequence; +} +extern "C" JNIEXPORT jstring JNICALL JNI_METHOD(nativeFirmware)(JNIEnv* env, jobject, jlong token) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return nullptr; + char value[256]{}; int length = 255; + if (xr_device_provider_get_glasses_version(session->device, value, &length) != 0) return nullptr; + value[255] = 0; + return env->NewStringUTF(value); +} +extern "C" JNIEXPORT jbyteArray JNICALL JNI_METHOD(nativeSerialHash)(JNIEnv* env, jobject, jlong token) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return nullptr; + uint8_t hash[32]{}; + const int rc = xr_device_provider_get_sn_hash(session->device, hash); + if (rc != 0) { report("read device identity", rc); return nullptr; } + auto result = env->NewByteArray(32); + if (result) env->SetByteArrayRegion(result, 0, 32, reinterpret_cast(hash)); + return result; +} +extern "C" JNIEXPORT jdoubleArray JNICALL JNI_METHOD(nativeSpatialDiagnostics)(JNIEnv* env, jobject, jlong token) { + std::lock_guard api(api_mutex); + if (!session || session->token != token) return nullptr; + std::lock_guard lock(camera_mutex); + double values[3] = {double(session->spatial_status), camera_pose_receipt ? (monotonic_ns()-camera_pose_receipt)/1e6 : -1.0, + camera_poses.empty() ? -1.0 : (camera_poses.back().time-camera_source)*1000.0}; + auto result=env->NewDoubleArray(3); + if(result)env->SetDoubleArrayRegion(result,0,3,values); + return result; +} +extern "C" JNIEXPORT jlong JNICALL JNI_METHOD(nativeStereo)(JNIEnv* env, jobject, jlong token, + jobject left, jobject right, jdoubleArray metadata, jfloatArray head, jboolean waitForPose) { + std::lock_guard api(api_mutex); + if (!session || session->token != token || !left || !right || !metadata || !head || + env->GetArrayLength(metadata) != 9 || env->GetArrayLength(head) != 7) return 0; + std::lock_guard lock(camera_mutex); + if (!camera_wanted || camera_sequence == camera_consumed || camera_left.empty()) return 0; + const auto size = camera_left.size(); + if (env->GetDirectBufferCapacity(left) < jlong(size) || env->GetDirectBufferCapacity(right) < jlong(size)) return -1; + auto l = env->GetDirectBufferAddress(left), r = env->GetDirectBufferAddress(right); + if (!l || !r) return -1; + const CameraPose *best = matched_camera_pose(camera_source); + if (waitForPose && !best && monotonic_ns()-camera_receipt < 35000000LL) return 0; + memcpy(l, camera_left.data(), size); memcpy(r, camera_right.data(), size); + double meta[9] = {double(camera_width), double(camera_height), camera_source, double(camera_receipt), + double(token), double(camera_sequence), best ? 1.0 : 0.0, + double(camera_input_sequence), double(camera_gate.skipped)}; + env->SetDoubleArrayRegion(metadata, 0, 9, meta); + if (best) env->SetFloatArrayRegion(head, 0, 7, best->pose.data()); + camera_consumed = camera_sequence; + return jlong(camera_sequence); +} +extern "C" JNIEXPORT jboolean JNICALL JNI_METHOD(nativeCameraSynchronized)(JNIEnv*, jobject, jlong token, jdouble source) { + std::lock_guard api(api_mutex); + if (!session || session->token != token || !std::isfinite(source)) return JNI_FALSE; + std::lock_guard lock(camera_mutex); + return camera_accepting && matched_camera_pose(source) != nullptr; +} + +namespace { +struct RgbUsbLog { + int savedStderr; + bool hadLevel; + std::string oldLevel; + explicit RgbUsbLog(int fd) : savedStderr(dup(STDERR_FILENO)), + hadLevel(getenv("LIBUSB_DEBUG") != nullptr), oldLevel(hadLevel ? getenv("LIBUSB_DEBUG") : "") { + fflush(stderr); + if (savedStderr >= 0) dup2(fd, STDERR_FILENO); + setenv("LIBUSB_DEBUG", "4", 1); + } + ~RgbUsbLog() { + fflush(stderr); + if (savedStderr >= 0) { dup2(savedStderr, STDERR_FILENO); close(savedStderr); } + if (hadLevel) setenv("LIBUSB_DEBUG", oldLevel.c_str(), 1); else unsetenv("LIBUSB_DEBUG"); + } +}; + +void rgb_usb_state(int fd, const char* stage) { + uint8_t alternate = 0; + usbdevfs_ctrltransfer request{}; + request.bRequestType=0x81; request.bRequest=0x0a; request.wIndex=1; + request.wLength=1; request.timeout=200; request.data=&alternate; + int result=ioctl(fd, USBDEVFS_CONTROL, &request); + fprintf(stderr,"RGB %s GET_INTERFACE result=%d errno=%d alternate=%u\n",stage,result,result<0 ? errno : 0,alternate); + for (int selector : {1, 2}) { + uint8_t size[2]{}; + request.bRequestType=0xa1; request.bRequest=0x85; request.wValue=selector << 8; + request.wLength=2; request.data=size; + result=ioctl(fd,USBDEVFS_CONTROL,&request); + const unsigned length=result==2 ? unsigned(size[0]) | unsigned(size[1]) << 8 : 26; + uint8_t bytes[64]{}; + request.bRequest=0x81; request.wLength=std::clamp(length,26u,64u); request.data=bytes; + result=ioctl(fd,USBDEVFS_CONTROL,&request); + fprintf(stderr,"RGB %s %s result=%d errno=%d bytes=",stage,selector==1 ? "PROBE" : "COMMIT",result,result<0 ? errno : 0); + for (int i=0;iGetArrayLength(metadata) != 7 || + !xr_camera_provider_is_valid_camera(vid, pid)) return nullptr; + RgbUsbLog usbLog(logFd); + rgb_usb_state(fd,"before-create"); + struct Capture { + std::mutex mutex; + std::condition_variable ready; + std::vector jpeg; + unsigned frames = 0; + jlong values[7]{}; + } capture; + auto camera = xr_camera_provider_create(vid, pid, fd); + if (!camera) { fprintf(stderr,"RGB provider create failed\n"); return nullptr; } + const int result = xr_camera_provider_start(camera, [](const XRCameraFrame* frame, void* data) { + auto& c = *static_cast(data); + std::lock_guard lock(c.mutex); + ++c.frames; + if (!frame || !frame->data || frame->format != XR_CAMERA_FORMAT_MJPEG || + frame->size < 4 || frame->size > 4 * 1024 * 1024) return; + c.jpeg.assign(frame->data, frame->data + frame->size); + c.values[0] = frame->width; c.values[1] = frame->height; + c.values[2] = frame->timestamp; c.values[3] = frame->sequence; + c.values[6] = monotonic_ns(); + c.ready.notify_one(); + }, &capture); + fprintf(stderr,"RGB start result=%d streaming=%d\n",result,xr_camera_provider_is_streaming(camera)); + rgb_usb_state(fd,"after-start"); + if (result == 0) { + { + std::unique_lock lock(capture.mutex); + capture.ready.wait_for(lock, std::chrono::seconds(5), [&] { return capture.frames >= 10 && !capture.jpeg.empty(); }); + } + fprintf(stderr,"RGB stop result=%d\n",xr_camera_provider_stop(camera)); + } + xr_camera_provider_destroy(camera); + rgb_usb_state(fd,"after-destroy"); + capture.values[4] = result; + capture.values[5] = capture.frames; + env->SetLongArrayRegion(metadata, 0, 7, capture.values); + if (capture.jpeg.empty()) return nullptr; + auto bytes = env->NewByteArray(static_cast(capture.jpeg.size())); + if (bytes) env->SetByteArrayRegion(bytes, 0, static_cast(capture.jpeg.size()), + reinterpret_cast(capture.jpeg.data())); + return bytes; +} diff --git a/app/src/main/cpp/viture/stereo_frame_gate.h b/app/src/main/cpp/viture/stereo_frame_gate.h new file mode 100644 index 0000000000..ae5a8f5ff1 --- /dev/null +++ b/app/src/main/cpp/viture/stereo_frame_gate.h @@ -0,0 +1,29 @@ +#pragma once +#include +#include + +struct StereoFrameGate { + uint64_t received = 0, skipped = 0; + void SetRatePermille(int rate) { + if (rate != 500 && rate != 600 && rate != 800 && rate != 1000) rate = 500; + if (ratePermille_ != rate) phase_ = 1000-rate; + ratePermille_ = rate; + } + void SetHalfRate(bool enabled) { + SetRatePermille(enabled ? 500 : 1000); + } + bool Accept(double source) { + if (!std::isfinite(source) || source <= 0) return false; + ++received; + if (source <= lastSource_) phase_ = 1000-ratePermille_; + lastSource_ = source; + phase_ += ratePermille_; + const bool copy = phase_ >= 1000; + if (copy) phase_ -= 1000; + if (!copy) ++skipped; + return copy; + } +private: + int ratePermille_ = 1000, phase_ = 0; + double lastSource_ = 0; +}; diff --git a/app/src/main/cpp/viture/uvc_bridge.cpp b/app/src/main/cpp/viture/uvc_bridge.cpp new file mode 100644 index 0000000000..38bf9a1051 --- /dev/null +++ b/app/src/main/cpp/viture/uvc_bridge.cpp @@ -0,0 +1,134 @@ +#include +#include +#include +#include "mjpeg_payload.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +namespace { +struct UsbLog { + int saved; + bool hadLevel; + std::string level; + explicit UsbLog(int fd) : saved(dup(STDERR_FILENO)), hadLevel(getenv("LIBUSB_DEBUG") != nullptr), + level(hadLevel ? getenv("LIBUSB_DEBUG") : "") { + fflush(stderr); + if (saved >= 0) dup2(fd, STDERR_FILENO); + setenv("LIBUSB_DEBUG", "3", 1); + libusb_set_log_cb(nullptr, [](libusb_context*, libusb_log_level, const char* text) { + fputs(text, stderr); + }, LIBUSB_LOG_CB_GLOBAL); + } + ~UsbLog() { + libusb_set_log_cb(nullptr, nullptr, LIBUSB_LOG_CB_GLOBAL); + fflush(stderr); + if (saved >= 0) { dup2(saved, STDERR_FILENO); close(saved); } + if (hadLevel) setenv("LIBUSB_DEBUG", level.c_str(), 1); else unsetenv("LIBUSB_DEBUG"); + } +}; + +struct Capture { + std::mutex mutex; + std::condition_variable ready; + std::vector jpeg; + jlong values[14]{}; + bool accepting = true; +}; + +jlong monotonic_ns() { + timespec now{}; + clock_gettime(CLOCK_MONOTONIC, &now); + return now.tv_sec*1000000000LL+now.tv_nsec; +} + +void finish_observation(Capture& capture) { + std::lock_guard lock(capture.mutex); + if (!capture.accepting) return; + capture.accepting = false; + capture.values[12] = monotonic_ns(); + if (capture.values[6]) capture.values[13] = capture.values[12]-capture.values[6]; + capture.values[8] = std::max(capture.values[8],capture.values[13]); +} + +void frame_received(uvc_frame_t* frame, void* user) { + auto& capture = *static_cast(user); + std::lock_guard lock(capture.mutex); + if (!capture.accepting) return; + ++capture.values[5]; + const auto* bytes = frame ? static_cast(frame->data) : nullptr; + const size_t size = frame ? frame->data_bytes : 0; + const size_t jpegSize = frame && frame->frame_format == UVC_FRAME_FORMAT_MJPEG ? mjpeg_payload_size(bytes,size) : 0; + if (!jpegSize) { + ++capture.values[10]; + return; + } + const jlong time = monotonic_ns(); + capture.values[0]=frame->width; capture.values[1]=frame->height; capture.values[3]=frame->sequence; + if (!capture.values[7]) capture.values[7]=time; + if (capture.values[6]) capture.values[8]=std::max(capture.values[8],time-capture.values[6]); + capture.values[6]=time; + ++capture.values[9]; + capture.values[11]+=jpegSize; + capture.jpeg.assign(bytes,bytes+jpegSize); + capture.ready.notify_one(); +} +} + +extern "C" JNIEXPORT jbyteArray JNICALL +Java_com_droiddeck_launcher_glasses_UvcRgbDiagnostic_nativeSnapshot(JNIEnv* env, jobject, + jint fd, jint width, jint height, jint fps, jint durationMs, jlongArray metadata, jint logFd) { + if (fd<0 || logFd<0 || !metadata || env->GetArrayLength(metadata)!=14 || width<160 || width>1920 || + height<120 || height>1080 || fps<5 || fps>30 || durationMs<1000 || durationMs>30000) return nullptr; + UsbLog log(logFd); + Capture capture; + uvc_context_t* context=nullptr; + uvc_device_handle_t* camera=nullptr; + libusb_set_option(nullptr,LIBUSB_OPTION_NO_DEVICE_DISCOVERY); + int result=uvc_init(&context,nullptr); + fprintf(stderr,"UVC init=%d\n",result); + if (result==0) { + result=uvc_wrap(fd,context,&camera); + fprintf(stderr,"UVC wrap=%d\n",result); + } + if (result==0) { + uvc_print_diag(camera,stderr); + uvc_stream_ctrl_t control{}; + result=uvc_get_stream_ctrl_format_size(camera,&control,UVC_FRAME_FORMAT_MJPEG,width,height,fps); + fprintf(stderr,"UVC negotiate=%d requested=%dx%d@%d\n",result,width,height,fps); + if (result==0) { + uvc_print_stream_ctrl(&control,stderr); + result=uvc_start_streaming(camera,&control,frame_received,&capture,0); + fprintf(stderr,"UVC start=%d\n",result); + if (result==0) { + { + std::unique_lock lock(capture.mutex); + if (capture.ready.wait_for(lock,std::chrono::seconds(5),[&] { return !capture.jpeg.empty(); })) + capture.ready.wait_for(lock,std::chrono::milliseconds(durationMs),[] { return false; }); + } + finish_observation(capture); + uvc_stop_streaming(camera); + } + } + } + finish_observation(capture); + if (camera) uvc_close(camera); + if (context) uvc_exit(context); + capture.values[4]=result; + fprintf(stderr,"UVC result=%d callbacks=%lld complete=%lld invalid=%lld maxGapMs=%.3f tailMs=%.3f\n",result, + static_cast(capture.values[5]),static_cast(capture.values[9]), + static_cast(capture.values[10]),capture.values[8]/1e6,capture.values[13]/1e6); + env->SetLongArrayRegion(metadata,0,14,capture.values); + if (result!=0 || capture.jpeg.empty()) return nullptr; + auto bytes=env->NewByteArray(static_cast(capture.jpeg.size())); + if (bytes) env->SetByteArrayRegion(bytes,0,static_cast(capture.jpeg.size()), + reinterpret_cast(capture.jpeg.data())); + return bytes; +} diff --git a/app/src/main/cpp/waylandcomp/CMakeLists.txt b/app/src/main/cpp/waylandcomp/CMakeLists.txt index bd7c4a6ba4..7f6e0f7d9f 100644 --- a/app/src/main/cpp/waylandcomp/CMakeLists.txt +++ b/app/src/main/cpp/waylandcomp/CMakeLists.txt @@ -3,6 +3,7 @@ add_library(droiddeckwayland SHARED src/vk_present.c src/effects_chain.c src/cardboard.c + src/spatialpose.c src/vk_loader.c src/sc_layer.c src/ahb_swapchain.c diff --git a/app/src/main/cpp/waylandcomp/src/cardboard.c b/app/src/main/cpp/waylandcomp/src/cardboard.c index 5e4d817014..fc09d2f030 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard.c +++ b/app/src/main/cpp/waylandcomp/src/cardboard.c @@ -28,7 +28,7 @@ static float clampf(float v, float lo, float hi) { return v < lo ? lo : v > hi ? void cardboard_clamp(struct cardboard_params *p) { p->enabled = p->enabled ? 1 : 0; - p->source = p->source == CARDBOARD_SOURCE_SBS ? CARDBOARD_SOURCE_SBS : CARDBOARD_SOURCE_SCREEN; + if (p->source < CARDBOARD_SOURCE_SCREEN || p->source > CARDBOARD_SOURCE_FLAT) p->source = CARDBOARD_SOURCE_SCREEN; p->ipd_m = clampf(p->ipd_m, 0.0f, 0.1f); p->screen_dist_m = clampf(p->screen_dist_m, 0.5f, 50.0f); p->screen_width_m = clampf(p->screen_width_m, 0.2f, 60.0f); @@ -62,8 +62,11 @@ void cardboard_push_constants(const struct cardboard_params *p, const float pose out[21] = out[22] = out[23] = 0.0f; } -#ifndef CARDBOARD_HOST_TEST +void cardboard_push_translation(const struct cardboard_params *p, const float position[3], float out[24]) { + for (int i = 0; i < 3; ++i) out[21+i] = p->source == CARDBOARD_SOURCE_SCREEN && isfinite(position[i]) ? position[i] : 0.0f; +} +#ifndef CARDBOARD_HOST_TEST static pthread_mutex_t g_lock = PTHREAD_MUTEX_INITIALIZER; static struct cardboard_params g_set = { @@ -72,6 +75,7 @@ static struct cardboard_params g_set = { static float g_pose[9] = {1, 0, 0, 0, 1, 0, 0, 0, 1}; static volatile int g_changed = 1; +static float g_position[3]; static int g_live; static void shm_publish(int live); @@ -86,7 +90,8 @@ void vkp_cardboard_set(const struct cardboard_params *p) { pthread_mutex_unlock(&g_lock); if (was != c.enabled || c.enabled) droiddeck_log("cardboard", "%s: %s%s, ipd %.0f mm, screen %.1f m wide at %.1f m, lens k1 %.2f k2 %.2f, fov %.0f, inset %.3f, chroma %.3f", - c.enabled ? "on" : "off", c.source == CARDBOARD_SOURCE_SBS ? "side-by-side source" : "virtual screen", + c.enabled ? "on" : "off", c.source == CARDBOARD_SOURCE_SBS ? "side-by-side source" : + c.source == CARDBOARD_SOURCE_FLAT ? "flat image in both eyes" : "virtual screen", c.mono ? " (one eye)" : "", c.ipd_m * 1000.0f, c.screen_width_m, c.screen_dist_m, c.k1, c.k2, c.fov_deg, c.lens_inset, c.chroma); } @@ -146,22 +151,31 @@ static void shm_publish(int live) { } -void vkp_cardboard_set_pose(const float m[9], int live) { +void vkp_cardboard_set_spatial_pose(const float m[9], const float position[3], int live) { pthread_mutex_lock(&g_lock); memcpy(g_pose, m, sizeof(g_pose)); + memcpy(g_position, position, sizeof(g_position)); g_live = live; if (g_set.enabled && g_set.source == CARDBOARD_SOURCE_SCREEN) g_changed = 1; shm_publish(live); pthread_mutex_unlock(&g_lock); } +void vkp_cardboard_set_pose(const float m[9], int live) { + const float zero[3] = {0}; + vkp_cardboard_set_spatial_pose(m, zero, live); +} + + static struct cardboard_params g_cur; static float g_cur_pose[9]; +static float g_cur_position[3]; static void snapshot(void) { pthread_mutex_lock(&g_lock); g_cur = g_set; memcpy(g_cur_pose, g_pose, sizeof(g_cur_pose)); + memcpy(g_cur_position, g_position, sizeof(g_cur_position)); pthread_mutex_unlock(&g_lock); } @@ -428,6 +442,7 @@ VkImage vkp_cardboard_run(VkCommandBuffer cmd, VkImage src, int src_w, int src_h } struct { float ndc[4]; float rest[24]; } pc = {{-1.0f, -1.0f, 1.0f, 1.0f}, {0}}; cardboard_push_constants(&g_cur, g_cur_pose, src_w, src_h, out_w, out_h, pc.rest); + cardboard_push_translation(&g_cur, g_cur_position, pc.rest); VkRenderPassBeginInfo rpi = {.sType = VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, .renderPass = g_rp, .framebuffer = g_t.fb, .renderArea = {{0, 0}, {(uint32_t)out_w, (uint32_t)out_h}}}; diff --git a/app/src/main/cpp/waylandcomp/src/cardboard.frag b/app/src/main/cpp/waylandcomp/src/cardboard.frag index eb2628b2e3..33298f7b87 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard.frag +++ b/app/src/main/cpp/waylandcomp/src/cardboard.frag @@ -24,14 +24,21 @@ vec3 eyeSample(vec2 tan, float eye) { if (pc.view.z > 0.5) { float tanH = pc.lens.z; vec2 s = vec2(tan.x / (tanH * pc.view.w), tan.y / tanH) * 0.5 + 0.5; + if (pc.view.z > 1.5) { + vec2 fit = max(vec2(pc.view.w / pc.view.y, pc.view.y / pc.view.w), vec2(1.0)); + s = (s - 0.5) * fit + 0.5; + if (any(lessThan(s, vec2(0.0))) || any(greaterThan(s, vec2(1.0)))) return vec3(0.0); + return texture(Source, s).rgb; + } if (any(lessThan(s, vec2(0.0))) || any(greaterThan(s, vec2(1.0)))) return vec3(0.0); return texture(Source, vec2((s.x + eye) * 0.5, s.y)).rgb; } mat3 R = transpose(mat3(pc.rot0.xyz, pc.rot1.xyz, pc.rot2.xyz)); vec3 d = R * normalize(vec3(tan.x, -tan.y, -1.0)); - vec3 o = R * vec3((eye < 0.5 ? -1.0 : 1.0) * pc.rot0.w, 0.0, 0.0); + vec3 o = pc.extra.yzw + R * vec3((eye < 0.5 ? -1.0 : 1.0) * pc.rot0.w, 0.0, 0.0); if (d.z > -1e-4) return BACKDROP; float t = (-pc.rot1.w - o.z) / d.z; + if (t <= 0.0) return BACKDROP; vec3 hit = o + d * t; float halfW = pc.rot2.w, halfH = halfW / pc.view.y; vec2 s = vec2(hit.x / halfW, -hit.y / halfH) * 0.5 + 0.5; diff --git a/app/src/main/cpp/waylandcomp/src/cardboard.h b/app/src/main/cpp/waylandcomp/src/cardboard.h index b1ff596893..88d5ea3ff7 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard.h +++ b/app/src/main/cpp/waylandcomp/src/cardboard.h @@ -3,7 +3,7 @@ #define VK_USE_PLATFORM_ANDROID_KHR #include -enum { CARDBOARD_SOURCE_SCREEN = 0, CARDBOARD_SOURCE_SBS = 1 }; +enum { CARDBOARD_SOURCE_SCREEN = 0, CARDBOARD_SOURCE_SBS = 1, CARDBOARD_SOURCE_FLAT = 2 }; struct cardboard_params { int enabled; @@ -21,6 +21,7 @@ struct cardboard_params { void vkp_cardboard_set(const struct cardboard_params *p); void vkp_cardboard_set_pose(const float m[9], int live); +void vkp_cardboard_set_spatial_pose(const float m[9], const float position[3], int live); void vkp_cardboard_set_pose_file(const char *path); void vkp_cardboard_set_render_height(int height); @@ -33,5 +34,6 @@ VkImage vkp_cardboard_run(VkCommandBuffer cmd, VkImage src, int src_w, int src_h void cardboard_clamp(struct cardboard_params *p); void cardboard_push_constants(const struct cardboard_params *p, const float pose[9], int src_w, int src_h, int out_w, int out_h, float out[24]); +void cardboard_push_translation(const struct cardboard_params *p, const float position[3], float out[24]); #endif diff --git a/app/src/main/cpp/waylandcomp/src/cardboard_frag.h b/app/src/main/cpp/waylandcomp/src/cardboard_frag.h index caebe0b5e3..f74676d6a9 100644 --- a/app/src/main/cpp/waylandcomp/src/cardboard_frag.h +++ b/app/src/main/cpp/waylandcomp/src/cardboard_frag.h @@ -1,8 +1,9 @@ + // 1115.1.0 #pragma once const uint32_t cardboard_frag_code[] = { - 0x07230203,0x00010000,0x0008000b,0x00000185,0x00000000,0x00020011,0x00000001,0x0006000b, + 0x07230203,0x00010000,0x0008000b,0x000001ba,0x00000000,0x00020011,0x00000001,0x0006000b, 0x00000001,0x4c534c47,0x6474732e,0x3035342e,0x00000000,0x0003000e,0x00000000,0x00000001, - 0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x000000f8,0x0000017d,0x00030010, + 0x0007000f,0x00000004,0x00000004,0x6e69616d,0x00000000,0x0000012d,0x000001b2,0x00030010, 0x00000004,0x00000007,0x00030003,0x00000002,0x000001c2,0x00040005,0x00000004,0x6e69616d, 0x00000000,0x00070005,0x0000000d,0x69646e75,0x726f7473,0x66762874,0x31663b32,0x0000003b, 0x00030005,0x0000000b,0x00000074,0x00040005,0x0000000c,0x6c616373,0x00000065,0x00070005, @@ -13,271 +14,304 @@ const uint32_t cardboard_frag_code[] = { 0x00050006,0x0000001e,0x00000003,0x32746f72,0x00000000,0x00050006,0x0000001e,0x00000004, 0x736e656c,0x00000000,0x00050006,0x0000001e,0x00000005,0x77656976,0x00000000,0x00050006, 0x0000001e,0x00000006,0x72747865,0x00000061,0x00030005,0x00000020,0x00006370,0x00040005, - 0x0000003f,0x486e6174,0x00000000,0x00030005,0x00000042,0x00000073,0x00040005,0x00000068, - 0x72756f53,0x00006563,0x00030005,0x00000077,0x00000052,0x00030005,0x00000094,0x00000064, - 0x00030005,0x0000009f,0x0000006f,0x00030005,0x000000b3,0x00000074,0x00030005,0x000000bd, - 0x00746968,0x00040005,0x000000c3,0x666c6168,0x00000057,0x00040005,0x000000c6,0x666c6168, - 0x00000048,0x00030005,0x000000cb,0x00000073,0x00040005,0x000000ed,0x6f6e6f6d,0x00000000, - 0x00030005,0x000000f2,0x00657965,0x00030005,0x000000f8,0x00007675,0x00040005,0x000000ff, - 0x61636f6c,0x0000006c,0x00030005,0x00000110,0x00007863,0x00030005,0x00000124,0x00000070, - 0x00040005,0x00000129,0x486e6174,0x00000000,0x00030005,0x0000012c,0x00000074,0x00030005, - 0x0000013d,0x00000063,0x00040005,0x00000141,0x61726170,0x0000006d,0x00040005,0x00000143, - 0x61726170,0x0000006d,0x00040005,0x00000145,0x61726170,0x0000006d,0x00040005,0x00000146, - 0x61726170,0x0000006d,0x00040005,0x0000014b,0x61726170,0x0000006d,0x00040005,0x0000014d, - 0x61726170,0x0000006d,0x00040005,0x0000014f,0x61726170,0x0000006d,0x00040005,0x00000150, - 0x61726170,0x0000006d,0x00040005,0x00000158,0x61726170,0x0000006d,0x00040005,0x0000015a, - 0x61726170,0x0000006d,0x00040005,0x0000015c,0x61726170,0x0000006d,0x00040005,0x0000015d, - 0x61726170,0x0000006d,0x00040005,0x00000163,0x61726170,0x0000006d,0x00040005,0x00000165, - 0x61726170,0x0000006d,0x00040005,0x00000167,0x61726170,0x0000006d,0x00040005,0x00000168, - 0x61726170,0x0000006d,0x00030005,0x0000016b,0x00000065,0x00040005,0x00000171,0x65646166, - 0x00000000,0x00050005,0x0000017d,0x4374756f,0x726f6c6f,0x00000000,0x00030047,0x0000001e, - 0x00000002,0x00050048,0x0000001e,0x00000000,0x00000023,0x00000000,0x00050048,0x0000001e, - 0x00000001,0x00000023,0x00000010,0x00050048,0x0000001e,0x00000002,0x00000023,0x00000020, - 0x00050048,0x0000001e,0x00000003,0x00000023,0x00000030,0x00050048,0x0000001e,0x00000004, - 0x00000023,0x00000040,0x00050048,0x0000001e,0x00000005,0x00000023,0x00000050,0x00050048, - 0x0000001e,0x00000006,0x00000023,0x00000060,0x00040047,0x00000068,0x00000021,0x00000000, - 0x00040047,0x00000068,0x00000022,0x00000000,0x00040047,0x000000f8,0x0000001e,0x00000000, - 0x00040047,0x0000017d,0x0000001e,0x00000000,0x00020013,0x00000002,0x00030021,0x00000003, - 0x00000002,0x00030016,0x00000006,0x00000020,0x00040017,0x00000007,0x00000006,0x00000002, - 0x00040020,0x00000008,0x00000007,0x00000007,0x00040020,0x00000009,0x00000007,0x00000006, - 0x00050021,0x0000000a,0x00000007,0x00000008,0x00000009,0x00040017,0x0000000f,0x00000006, - 0x00000003,0x00050021,0x00000010,0x0000000f,0x00000008,0x00000009,0x0004002b,0x00000006, - 0x0000001c,0x3f800000,0x00040017,0x0000001d,0x00000006,0x00000004,0x0009001e,0x0000001e, - 0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x00040020, - 0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f,0x00000020,0x00000009,0x00040015, - 0x00000021,0x00000020,0x00000001,0x0004002b,0x00000021,0x00000022,0x00000004,0x00040015, - 0x00000023,0x00000020,0x00000000,0x0004002b,0x00000023,0x00000024,0x00000000,0x00040020, - 0x00000025,0x00000009,0x00000006,0x0004002b,0x00000023,0x0000002b,0x00000001,0x0004002b, - 0x00000021,0x00000036,0x00000005,0x0004002b,0x00000023,0x00000037,0x00000002,0x0004002b, - 0x00000006,0x0000003a,0x3f000000,0x00020014,0x0000003b,0x0004002b,0x00000023,0x00000046, - 0x00000003,0x0004002b,0x00000006,0x00000054,0x00000000,0x0005002c,0x00000007,0x00000055, - 0x00000054,0x00000054,0x00040017,0x00000056,0x0000003b,0x00000002,0x0005002c,0x00000007, - 0x0000005d,0x0000001c,0x0000001c,0x0006002c,0x0000000f,0x00000063,0x00000054,0x00000054, - 0x00000054,0x00090019,0x00000065,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000, - 0x00000001,0x00000000,0x0003001b,0x00000066,0x00000065,0x00040020,0x00000067,0x00000000, - 0x00000066,0x0004003b,0x00000067,0x00000068,0x00000000,0x00040018,0x00000075,0x0000000f, - 0x00000003,0x00040020,0x00000076,0x00000007,0x00000075,0x0004002b,0x00000021,0x00000078, - 0x00000001,0x00040020,0x00000079,0x00000009,0x0000001d,0x0004002b,0x00000021,0x0000007d, - 0x00000002,0x0004002b,0x00000021,0x00000081,0x00000003,0x00040020,0x00000093,0x00000007, - 0x0000000f,0x0004002b,0x00000006,0x0000009b,0xbf800000,0x0004002b,0x00000006,0x000000ab, - 0xb8d1b717,0x0004002b,0x00000006,0x000000af,0x3c75c28f,0x0004002b,0x00000006,0x000000b0, - 0x3ca3d70a,0x0006002c,0x0000000f,0x000000b1,0x000000af,0x000000af,0x000000b0,0x00040020, - 0x000000ec,0x00000007,0x0000003b,0x0004002b,0x00000021,0x000000ee,0x00000006,0x00040020, - 0x000000f7,0x00000001,0x00000007,0x0004003b,0x000000f7,0x000000f8,0x00000001,0x00040020, - 0x000000f9,0x00000001,0x00000006,0x0004002b,0x00000006,0x00000108,0x40000000,0x0004002b, - 0x00000006,0x00000172,0x3cf5c28f,0x00040020,0x0000017c,0x00000003,0x0000001d,0x0004003b, - 0x0000017c,0x0000017d,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003, - 0x000200f8,0x00000005,0x0004003b,0x000000ec,0x000000ed,0x00000007,0x0004003b,0x00000009, - 0x000000f2,0x00000007,0x0004003b,0x00000008,0x000000ff,0x00000007,0x0004003b,0x00000008, - 0x00000101,0x00000007,0x0004003b,0x00000009,0x00000110,0x00000007,0x0004003b,0x00000009, - 0x00000112,0x00000007,0x0004003b,0x00000009,0x00000118,0x00000007,0x0004003b,0x00000008, - 0x00000124,0x00000007,0x0004003b,0x00000009,0x00000129,0x00000007,0x0004003b,0x00000008, - 0x0000012c,0x00000007,0x0004003b,0x00000093,0x0000013d,0x00000007,0x0004003b,0x00000008, - 0x00000141,0x00000007,0x0004003b,0x00000009,0x00000143,0x00000007,0x0004003b,0x00000008, - 0x00000145,0x00000007,0x0004003b,0x00000009,0x00000146,0x00000007,0x0004003b,0x00000008, - 0x0000014b,0x00000007,0x0004003b,0x00000009,0x0000014d,0x00000007,0x0004003b,0x00000008, - 0x0000014f,0x00000007,0x0004003b,0x00000009,0x00000150,0x00000007,0x0004003b,0x00000008, - 0x00000158,0x00000007,0x0004003b,0x00000009,0x0000015a,0x00000007,0x0004003b,0x00000008, - 0x0000015c,0x00000007,0x0004003b,0x00000009,0x0000015d,0x00000007,0x0004003b,0x00000008, - 0x00000163,0x00000007,0x0004003b,0x00000009,0x00000165,0x00000007,0x0004003b,0x00000008, - 0x00000167,0x00000007,0x0004003b,0x00000009,0x00000168,0x00000007,0x0004003b,0x00000008, - 0x0000016b,0x00000007,0x0004003b,0x00000009,0x00000171,0x00000007,0x00060041,0x00000025, - 0x000000ef,0x00000020,0x000000ee,0x00000024,0x0004003d,0x00000006,0x000000f0,0x000000ef, - 0x000500ba,0x0000003b,0x000000f1,0x000000f0,0x0000003a,0x0003003e,0x000000ed,0x000000f1, - 0x0004003d,0x0000003b,0x000000f3,0x000000ed,0x000400a8,0x0000003b,0x000000f4,0x000000f3, - 0x000300f7,0x000000f6,0x00000000,0x000400fa,0x000000f4,0x000000f5,0x000000f6,0x000200f8, - 0x000000f5,0x00050041,0x000000f9,0x000000fa,0x000000f8,0x00000024,0x0004003d,0x00000006, - 0x000000fb,0x000000fa,0x000500b8,0x0000003b,0x000000fc,0x000000fb,0x0000003a,0x000200f9, - 0x000000f6,0x000200f8,0x000000f6,0x000700f5,0x0000003b,0x000000fd,0x000000f3,0x00000005, - 0x000000fc,0x000000f5,0x000600a9,0x00000006,0x000000fe,0x000000fd,0x00000054,0x0000001c, - 0x0003003e,0x000000f2,0x000000fe,0x0004003d,0x0000003b,0x00000100,0x000000ed,0x000300f7, - 0x00000103,0x00000000,0x000400fa,0x00000100,0x00000102,0x00000105,0x000200f8,0x00000102, - 0x0004003d,0x00000007,0x00000104,0x000000f8,0x0003003e,0x00000101,0x00000104,0x000200f9, - 0x00000103,0x000200f8,0x00000105,0x00050041,0x000000f9,0x00000106,0x000000f8,0x00000024, - 0x0004003d,0x00000006,0x00000107,0x00000106,0x00050085,0x00000006,0x00000109,0x00000107, - 0x00000108,0x0004003d,0x00000006,0x0000010a,0x000000f2,0x00050083,0x00000006,0x0000010b, - 0x00000109,0x0000010a,0x00050041,0x000000f9,0x0000010c,0x000000f8,0x0000002b,0x0004003d, - 0x00000006,0x0000010d,0x0000010c,0x00050050,0x00000007,0x0000010e,0x0000010b,0x0000010d, - 0x0003003e,0x00000101,0x0000010e,0x000200f9,0x00000103,0x000200f8,0x00000103,0x0004003d, - 0x00000007,0x0000010f,0x00000101,0x0003003e,0x000000ff,0x0000010f,0x0004003d,0x0000003b, - 0x00000111,0x000000ed,0x000300f7,0x00000114,0x00000000,0x000400fa,0x00000111,0x00000113, - 0x00000115,0x000200f8,0x00000113,0x0003003e,0x00000112,0x0000003a,0x000200f9,0x00000114, - 0x000200f8,0x00000115,0x0004003d,0x00000006,0x00000116,0x000000f2,0x000500b8,0x0000003b, - 0x00000117,0x00000116,0x0000003a,0x000300f7,0x0000011a,0x00000000,0x000400fa,0x00000117, - 0x00000119,0x0000011d,0x000200f8,0x00000119,0x00060041,0x00000025,0x0000011b,0x00000020, - 0x00000036,0x00000024,0x0004003d,0x00000006,0x0000011c,0x0000011b,0x0003003e,0x00000118, - 0x0000011c,0x000200f9,0x0000011a,0x000200f8,0x0000011d,0x00060041,0x00000025,0x0000011e, - 0x00000020,0x00000036,0x00000024,0x0004003d,0x00000006,0x0000011f,0x0000011e,0x0004007f, - 0x00000006,0x00000120,0x0000011f,0x0003003e,0x00000118,0x00000120,0x000200f9,0x0000011a, - 0x000200f8,0x0000011a,0x0004003d,0x00000006,0x00000121,0x00000118,0x00050081,0x00000006, - 0x00000122,0x0000003a,0x00000121,0x0003003e,0x00000112,0x00000122,0x000200f9,0x00000114, - 0x000200f8,0x00000114,0x0004003d,0x00000006,0x00000123,0x00000112,0x0003003e,0x00000110, - 0x00000123,0x0004003d,0x00000007,0x00000125,0x000000ff,0x0004003d,0x00000006,0x00000126, - 0x00000110,0x00050050,0x00000007,0x00000127,0x00000126,0x0000003a,0x00050083,0x00000007, - 0x00000128,0x00000125,0x00000127,0x0003003e,0x00000124,0x00000128,0x00060041,0x00000025, - 0x0000012a,0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006,0x0000012b,0x0000012a, - 0x0003003e,0x00000129,0x0000012b,0x00050041,0x00000009,0x0000012d,0x00000124,0x00000024, - 0x0004003d,0x00000006,0x0000012e,0x0000012d,0x00060041,0x00000025,0x0000012f,0x00000020, - 0x00000036,0x00000046,0x0004003d,0x00000006,0x00000130,0x0000012f,0x00050085,0x00000006, - 0x00000131,0x0000012e,0x00000130,0x00050041,0x00000009,0x00000132,0x00000124,0x0000002b, - 0x0004003d,0x00000006,0x00000133,0x00000132,0x00050050,0x00000007,0x00000134,0x00000131, - 0x00000133,0x0005008e,0x00000007,0x00000135,0x00000134,0x00000108,0x0004003d,0x00000006, - 0x00000136,0x00000129,0x0005008e,0x00000007,0x00000137,0x00000135,0x00000136,0x0003003e, - 0x0000012c,0x00000137,0x00060041,0x00000025,0x00000138,0x00000020,0x00000022,0x00000046, - 0x0004003d,0x00000006,0x00000139,0x00000138,0x000500ba,0x0000003b,0x0000013a,0x00000139, - 0x00000054,0x000300f7,0x0000013c,0x00000000,0x000400fa,0x0000013a,0x0000013b,0x00000162, - 0x000200f8,0x0000013b,0x00060041,0x00000025,0x0000013e,0x00000020,0x00000022,0x00000046, - 0x0004003d,0x00000006,0x0000013f,0x0000013e,0x00050083,0x00000006,0x00000140,0x0000001c, - 0x0000013f,0x0004003d,0x00000007,0x00000142,0x0000012c,0x0003003e,0x00000141,0x00000142, - 0x0003003e,0x00000143,0x00000140,0x00060039,0x00000007,0x00000144,0x0000000d,0x00000141, - 0x00000143,0x0003003e,0x00000145,0x00000144,0x0004003d,0x00000006,0x00000147,0x000000f2, - 0x0003003e,0x00000146,0x00000147,0x00060039,0x0000000f,0x00000148,0x00000013,0x00000145, - 0x00000146,0x00050051,0x00000006,0x00000149,0x00000148,0x00000000,0x00050041,0x00000009, - 0x0000014a,0x0000013d,0x00000024,0x0003003e,0x0000014a,0x00000149,0x0004003d,0x00000007, - 0x0000014c,0x0000012c,0x0003003e,0x0000014b,0x0000014c,0x0003003e,0x0000014d,0x0000001c, - 0x00060039,0x00000007,0x0000014e,0x0000000d,0x0000014b,0x0000014d,0x0003003e,0x0000014f, - 0x0000014e,0x0004003d,0x00000006,0x00000151,0x000000f2,0x0003003e,0x00000150,0x00000151, - 0x00060039,0x0000000f,0x00000152,0x00000013,0x0000014f,0x00000150,0x00050051,0x00000006, - 0x00000153,0x00000152,0x00000001,0x00050041,0x00000009,0x00000154,0x0000013d,0x0000002b, - 0x0003003e,0x00000154,0x00000153,0x00060041,0x00000025,0x00000155,0x00000020,0x00000022, - 0x00000046,0x0004003d,0x00000006,0x00000156,0x00000155,0x00050081,0x00000006,0x00000157, - 0x0000001c,0x00000156,0x0004003d,0x00000007,0x00000159,0x0000012c,0x0003003e,0x00000158, - 0x00000159,0x0003003e,0x0000015a,0x00000157,0x00060039,0x00000007,0x0000015b,0x0000000d, - 0x00000158,0x0000015a,0x0003003e,0x0000015c,0x0000015b,0x0004003d,0x00000006,0x0000015e, - 0x000000f2,0x0003003e,0x0000015d,0x0000015e,0x00060039,0x0000000f,0x0000015f,0x00000013, - 0x0000015c,0x0000015d,0x00050051,0x00000006,0x00000160,0x0000015f,0x00000002,0x00050041, - 0x00000009,0x00000161,0x0000013d,0x00000037,0x0003003e,0x00000161,0x00000160,0x000200f9, - 0x0000013c,0x000200f8,0x00000162,0x0004003d,0x00000007,0x00000164,0x0000012c,0x0003003e, - 0x00000163,0x00000164,0x0003003e,0x00000165,0x0000001c,0x00060039,0x00000007,0x00000166, - 0x0000000d,0x00000163,0x00000165,0x0003003e,0x00000167,0x00000166,0x0004003d,0x00000006, - 0x00000169,0x000000f2,0x0003003e,0x00000168,0x00000169,0x00060039,0x0000000f,0x0000016a, - 0x00000013,0x00000167,0x00000168,0x0003003e,0x0000013d,0x0000016a,0x000200f9,0x0000013c, - 0x000200f8,0x0000013c,0x0004003d,0x00000007,0x0000016c,0x000000ff,0x0004003d,0x00000007, - 0x0000016d,0x000000ff,0x00050050,0x00000007,0x0000016e,0x0000001c,0x0000001c,0x00050083, - 0x00000007,0x0000016f,0x0000016e,0x0000016d,0x0007000c,0x00000007,0x00000170,0x00000001, - 0x00000025,0x0000016c,0x0000016f,0x0003003e,0x0000016b,0x00000170,0x00050041,0x00000009, - 0x00000173,0x0000016b,0x00000024,0x0004003d,0x00000006,0x00000174,0x00000173,0x00060041, - 0x00000025,0x00000175,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x00000176, - 0x00000175,0x00050085,0x00000006,0x00000177,0x00000174,0x00000176,0x00050041,0x00000009, - 0x00000178,0x0000016b,0x0000002b,0x0004003d,0x00000006,0x00000179,0x00000178,0x0007000c, - 0x00000006,0x0000017a,0x00000001,0x00000025,0x00000177,0x00000179,0x0008000c,0x00000006, - 0x0000017b,0x00000001,0x00000031,0x00000054,0x00000172,0x0000017a,0x0003003e,0x00000171, - 0x0000017b,0x0004003d,0x0000000f,0x0000017e,0x0000013d,0x0004003d,0x00000006,0x0000017f, - 0x00000171,0x0005008e,0x0000000f,0x00000180,0x0000017e,0x0000017f,0x00050051,0x00000006, - 0x00000181,0x00000180,0x00000000,0x00050051,0x00000006,0x00000182,0x00000180,0x00000001, - 0x00050051,0x00000006,0x00000183,0x00000180,0x00000002,0x00070050,0x0000001d,0x00000184, - 0x00000181,0x00000182,0x00000183,0x0000001c,0x0003003e,0x0000017d,0x00000184,0x000100fd, - 0x00010038,0x00050036,0x00000007,0x0000000d,0x00000000,0x0000000a,0x00030037,0x00000008, - 0x0000000b,0x00030037,0x00000009,0x0000000c,0x000200f8,0x0000000e,0x0004003b,0x00000009, - 0x00000015,0x00000007,0x0004003d,0x00000007,0x00000016,0x0000000b,0x0004003d,0x00000007, - 0x00000017,0x0000000b,0x00050094,0x00000006,0x00000018,0x00000016,0x00000017,0x0003003e, - 0x00000015,0x00000018,0x0004003d,0x00000007,0x00000019,0x0000000b,0x0004003d,0x00000006, - 0x0000001a,0x0000000c,0x0005008e,0x00000007,0x0000001b,0x00000019,0x0000001a,0x00060041, - 0x00000025,0x00000026,0x00000020,0x00000022,0x00000024,0x0004003d,0x00000006,0x00000027, - 0x00000026,0x0004003d,0x00000006,0x00000028,0x00000015,0x00050085,0x00000006,0x00000029, - 0x00000027,0x00000028,0x00050081,0x00000006,0x0000002a,0x0000001c,0x00000029,0x00060041, - 0x00000025,0x0000002c,0x00000020,0x00000022,0x0000002b,0x0004003d,0x00000006,0x0000002d, - 0x0000002c,0x0004003d,0x00000006,0x0000002e,0x00000015,0x00050085,0x00000006,0x0000002f, - 0x0000002d,0x0000002e,0x0004003d,0x00000006,0x00000030,0x00000015,0x00050085,0x00000006, - 0x00000031,0x0000002f,0x00000030,0x00050081,0x00000006,0x00000032,0x0000002a,0x00000031, - 0x0005008e,0x00000007,0x00000033,0x0000001b,0x00000032,0x000200fe,0x00000033,0x00010038, - 0x00050036,0x0000000f,0x00000013,0x00000000,0x00000010,0x00030037,0x00000008,0x00000011, - 0x00030037,0x00000009,0x00000012,0x000200f8,0x00000014,0x0004003b,0x00000009,0x0000003f, - 0x00000007,0x0004003b,0x00000008,0x00000042,0x00000007,0x0004003b,0x00000076,0x00000077, - 0x00000007,0x0004003b,0x00000093,0x00000094,0x00000007,0x0004003b,0x00000093,0x0000009f, - 0x00000007,0x0004003b,0x00000009,0x000000b3,0x00000007,0x0004003b,0x00000093,0x000000bd, - 0x00000007,0x0004003b,0x00000009,0x000000c3,0x00000007,0x0004003b,0x00000009,0x000000c6, - 0x00000007,0x0004003b,0x00000008,0x000000cb,0x00000007,0x00060041,0x00000025,0x00000038, - 0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006,0x00000039,0x00000038,0x000500ba, - 0x0000003b,0x0000003c,0x00000039,0x0000003a,0x000300f7,0x0000003e,0x00000000,0x000400fa, - 0x0000003c,0x0000003d,0x0000003e,0x000200f8,0x0000003d,0x00060041,0x00000025,0x00000040, - 0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006,0x00000041,0x00000040,0x0003003e, - 0x0000003f,0x00000041,0x00050041,0x00000009,0x00000043,0x00000011,0x00000024,0x0004003d, - 0x00000006,0x00000044,0x00000043,0x0004003d,0x00000006,0x00000045,0x0000003f,0x00060041, - 0x00000025,0x00000047,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x00000048, - 0x00000047,0x00050085,0x00000006,0x00000049,0x00000045,0x00000048,0x00050088,0x00000006, - 0x0000004a,0x00000044,0x00000049,0x00050041,0x00000009,0x0000004b,0x00000011,0x0000002b, - 0x0004003d,0x00000006,0x0000004c,0x0000004b,0x0004003d,0x00000006,0x0000004d,0x0000003f, - 0x00050088,0x00000006,0x0000004e,0x0000004c,0x0000004d,0x00050050,0x00000007,0x0000004f, - 0x0000004a,0x0000004e,0x0005008e,0x00000007,0x00000050,0x0000004f,0x0000003a,0x00050050, - 0x00000007,0x00000051,0x0000003a,0x0000003a,0x00050081,0x00000007,0x00000052,0x00000050, - 0x00000051,0x0003003e,0x00000042,0x00000052,0x0004003d,0x00000007,0x00000053,0x00000042, - 0x000500b8,0x00000056,0x00000057,0x00000053,0x00000055,0x0004009a,0x0000003b,0x00000058, - 0x00000057,0x000400a8,0x0000003b,0x00000059,0x00000058,0x000300f7,0x0000005b,0x00000000, - 0x000400fa,0x00000059,0x0000005a,0x0000005b,0x000200f8,0x0000005a,0x0004003d,0x00000007, - 0x0000005c,0x00000042,0x000500ba,0x00000056,0x0000005e,0x0000005c,0x0000005d,0x0004009a, - 0x0000003b,0x0000005f,0x0000005e,0x000200f9,0x0000005b,0x000200f8,0x0000005b,0x000700f5, - 0x0000003b,0x00000060,0x00000058,0x0000003d,0x0000005f,0x0000005a,0x000300f7,0x00000062, - 0x00000000,0x000400fa,0x00000060,0x00000061,0x00000062,0x000200f8,0x00000061,0x000200fe, - 0x00000063,0x000200f8,0x00000062,0x0004003d,0x00000066,0x00000069,0x00000068,0x00050041, - 0x00000009,0x0000006a,0x00000042,0x00000024,0x0004003d,0x00000006,0x0000006b,0x0000006a, - 0x0004003d,0x00000006,0x0000006c,0x00000012,0x00050081,0x00000006,0x0000006d,0x0000006b, - 0x0000006c,0x00050085,0x00000006,0x0000006e,0x0000006d,0x0000003a,0x00050041,0x00000009, - 0x0000006f,0x00000042,0x0000002b,0x0004003d,0x00000006,0x00000070,0x0000006f,0x00050050, - 0x00000007,0x00000071,0x0000006e,0x00000070,0x00050057,0x0000001d,0x00000072,0x00000069, - 0x00000071,0x0008004f,0x0000000f,0x00000073,0x00000072,0x00000072,0x00000000,0x00000001, - 0x00000002,0x000200fe,0x00000073,0x000200f8,0x0000003e,0x00050041,0x00000079,0x0000007a, - 0x00000020,0x00000078,0x0004003d,0x0000001d,0x0000007b,0x0000007a,0x0008004f,0x0000000f, - 0x0000007c,0x0000007b,0x0000007b,0x00000000,0x00000001,0x00000002,0x00050041,0x00000079, - 0x0000007e,0x00000020,0x0000007d,0x0004003d,0x0000001d,0x0000007f,0x0000007e,0x0008004f, - 0x0000000f,0x00000080,0x0000007f,0x0000007f,0x00000000,0x00000001,0x00000002,0x00050041, - 0x00000079,0x00000082,0x00000020,0x00000081,0x0004003d,0x0000001d,0x00000083,0x00000082, - 0x0008004f,0x0000000f,0x00000084,0x00000083,0x00000083,0x00000000,0x00000001,0x00000002, - 0x00050051,0x00000006,0x00000085,0x0000007c,0x00000000,0x00050051,0x00000006,0x00000086, - 0x0000007c,0x00000001,0x00050051,0x00000006,0x00000087,0x0000007c,0x00000002,0x00050051, - 0x00000006,0x00000088,0x00000080,0x00000000,0x00050051,0x00000006,0x00000089,0x00000080, - 0x00000001,0x00050051,0x00000006,0x0000008a,0x00000080,0x00000002,0x00050051,0x00000006, - 0x0000008b,0x00000084,0x00000000,0x00050051,0x00000006,0x0000008c,0x00000084,0x00000001, - 0x00050051,0x00000006,0x0000008d,0x00000084,0x00000002,0x00060050,0x0000000f,0x0000008e, - 0x00000085,0x00000086,0x00000087,0x00060050,0x0000000f,0x0000008f,0x00000088,0x00000089, - 0x0000008a,0x00060050,0x0000000f,0x00000090,0x0000008b,0x0000008c,0x0000008d,0x00060050, - 0x00000075,0x00000091,0x0000008e,0x0000008f,0x00000090,0x00040054,0x00000075,0x00000092, - 0x00000091,0x0003003e,0x00000077,0x00000092,0x0004003d,0x00000075,0x00000095,0x00000077, - 0x00050041,0x00000009,0x00000096,0x00000011,0x00000024,0x0004003d,0x00000006,0x00000097, - 0x00000096,0x00050041,0x00000009,0x00000098,0x00000011,0x0000002b,0x0004003d,0x00000006, - 0x00000099,0x00000098,0x0004007f,0x00000006,0x0000009a,0x00000099,0x00060050,0x0000000f, - 0x0000009c,0x00000097,0x0000009a,0x0000009b,0x0006000c,0x0000000f,0x0000009d,0x00000001, - 0x00000045,0x0000009c,0x00050091,0x0000000f,0x0000009e,0x00000095,0x0000009d,0x0003003e, - 0x00000094,0x0000009e,0x0004003d,0x00000075,0x000000a0,0x00000077,0x0004003d,0x00000006, - 0x000000a1,0x00000012,0x000500b8,0x0000003b,0x000000a2,0x000000a1,0x0000003a,0x000600a9, - 0x00000006,0x000000a3,0x000000a2,0x0000009b,0x0000001c,0x00060041,0x00000025,0x000000a4, - 0x00000020,0x00000078,0x00000046,0x0004003d,0x00000006,0x000000a5,0x000000a4,0x00050085, - 0x00000006,0x000000a6,0x000000a3,0x000000a5,0x00060050,0x0000000f,0x000000a7,0x000000a6, - 0x00000054,0x00000054,0x00050091,0x0000000f,0x000000a8,0x000000a0,0x000000a7,0x0003003e, - 0x0000009f,0x000000a8,0x00050041,0x00000009,0x000000a9,0x00000094,0x00000037,0x0004003d, - 0x00000006,0x000000aa,0x000000a9,0x000500ba,0x0000003b,0x000000ac,0x000000aa,0x000000ab, - 0x000300f7,0x000000ae,0x00000000,0x000400fa,0x000000ac,0x000000ad,0x000000ae,0x000200f8, - 0x000000ad,0x000200fe,0x000000b1,0x000200f8,0x000000ae,0x00060041,0x00000025,0x000000b4, - 0x00000020,0x0000007d,0x00000046,0x0004003d,0x00000006,0x000000b5,0x000000b4,0x0004007f, - 0x00000006,0x000000b6,0x000000b5,0x00050041,0x00000009,0x000000b7,0x0000009f,0x00000037, - 0x0004003d,0x00000006,0x000000b8,0x000000b7,0x00050083,0x00000006,0x000000b9,0x000000b6, - 0x000000b8,0x00050041,0x00000009,0x000000ba,0x00000094,0x00000037,0x0004003d,0x00000006, - 0x000000bb,0x000000ba,0x00050088,0x00000006,0x000000bc,0x000000b9,0x000000bb,0x0003003e, - 0x000000b3,0x000000bc,0x0004003d,0x0000000f,0x000000be,0x0000009f,0x0004003d,0x0000000f, - 0x000000bf,0x00000094,0x0004003d,0x00000006,0x000000c0,0x000000b3,0x0005008e,0x0000000f, - 0x000000c1,0x000000bf,0x000000c0,0x00050081,0x0000000f,0x000000c2,0x000000be,0x000000c1, - 0x0003003e,0x000000bd,0x000000c2,0x00060041,0x00000025,0x000000c4,0x00000020,0x00000081, - 0x00000046,0x0004003d,0x00000006,0x000000c5,0x000000c4,0x0003003e,0x000000c3,0x000000c5, - 0x0004003d,0x00000006,0x000000c7,0x000000c3,0x00060041,0x00000025,0x000000c8,0x00000020, - 0x00000036,0x0000002b,0x0004003d,0x00000006,0x000000c9,0x000000c8,0x00050088,0x00000006, - 0x000000ca,0x000000c7,0x000000c9,0x0003003e,0x000000c6,0x000000ca,0x00050041,0x00000009, - 0x000000cc,0x000000bd,0x00000024,0x0004003d,0x00000006,0x000000cd,0x000000cc,0x0004003d, - 0x00000006,0x000000ce,0x000000c3,0x00050088,0x00000006,0x000000cf,0x000000cd,0x000000ce, - 0x00050041,0x00000009,0x000000d0,0x000000bd,0x0000002b,0x0004003d,0x00000006,0x000000d1, - 0x000000d0,0x0004007f,0x00000006,0x000000d2,0x000000d1,0x0004003d,0x00000006,0x000000d3, - 0x000000c6,0x00050088,0x00000006,0x000000d4,0x000000d2,0x000000d3,0x00050050,0x00000007, - 0x000000d5,0x000000cf,0x000000d4,0x0005008e,0x00000007,0x000000d6,0x000000d5,0x0000003a, - 0x00050050,0x00000007,0x000000d7,0x0000003a,0x0000003a,0x00050081,0x00000007,0x000000d8, - 0x000000d6,0x000000d7,0x0003003e,0x000000cb,0x000000d8,0x0004003d,0x00000007,0x000000d9, - 0x000000cb,0x000500b8,0x00000056,0x000000da,0x000000d9,0x00000055,0x0004009a,0x0000003b, - 0x000000db,0x000000da,0x000400a8,0x0000003b,0x000000dc,0x000000db,0x000300f7,0x000000de, - 0x00000000,0x000400fa,0x000000dc,0x000000dd,0x000000de,0x000200f8,0x000000dd,0x0004003d, - 0x00000007,0x000000df,0x000000cb,0x000500ba,0x00000056,0x000000e0,0x000000df,0x0000005d, - 0x0004009a,0x0000003b,0x000000e1,0x000000e0,0x000200f9,0x000000de,0x000200f8,0x000000de, - 0x000700f5,0x0000003b,0x000000e2,0x000000db,0x000000ae,0x000000e1,0x000000dd,0x000300f7, - 0x000000e4,0x00000000,0x000400fa,0x000000e2,0x000000e3,0x000000e4,0x000200f8,0x000000e3, - 0x000200fe,0x000000b1,0x000200f8,0x000000e4,0x0004003d,0x00000066,0x000000e6,0x00000068, - 0x0004003d,0x00000007,0x000000e7,0x000000cb,0x00050057,0x0000001d,0x000000e8,0x000000e6, - 0x000000e7,0x0008004f,0x0000000f,0x000000e9,0x000000e8,0x000000e8,0x00000000,0x00000001, - 0x00000002,0x000200fe,0x000000e9,0x00010038 + 0x0000003f,0x486e6174,0x00000000,0x00030005,0x00000042,0x00000073,0x00030005,0x00000059, + 0x00746966,0x00040005,0x00000082,0x72756f53,0x00006563,0x00030005,0x000000a3,0x00000052, + 0x00030005,0x000000c0,0x00000064,0x00030005,0x000000cb,0x0000006f,0x00030005,0x000000e4, + 0x00000074,0x00030005,0x000000f3,0x00746968,0x00040005,0x000000f9,0x666c6168,0x00000057, + 0x00040005,0x000000fc,0x666c6168,0x00000048,0x00030005,0x00000101,0x00000073,0x00040005, + 0x00000123,0x6f6e6f6d,0x00000000,0x00030005,0x00000127,0x00657965,0x00030005,0x0000012d, + 0x00007675,0x00040005,0x00000134,0x61636f6c,0x0000006c,0x00030005,0x00000145,0x00007863, + 0x00030005,0x00000159,0x00000070,0x00040005,0x0000015e,0x486e6174,0x00000000,0x00030005, + 0x00000161,0x00000074,0x00030005,0x00000172,0x00000063,0x00040005,0x00000176,0x61726170, + 0x0000006d,0x00040005,0x00000178,0x61726170,0x0000006d,0x00040005,0x0000017a,0x61726170, + 0x0000006d,0x00040005,0x0000017b,0x61726170,0x0000006d,0x00040005,0x00000180,0x61726170, + 0x0000006d,0x00040005,0x00000182,0x61726170,0x0000006d,0x00040005,0x00000184,0x61726170, + 0x0000006d,0x00040005,0x00000185,0x61726170,0x0000006d,0x00040005,0x0000018d,0x61726170, + 0x0000006d,0x00040005,0x0000018f,0x61726170,0x0000006d,0x00040005,0x00000191,0x61726170, + 0x0000006d,0x00040005,0x00000192,0x61726170,0x0000006d,0x00040005,0x00000198,0x61726170, + 0x0000006d,0x00040005,0x0000019a,0x61726170,0x0000006d,0x00040005,0x0000019c,0x61726170, + 0x0000006d,0x00040005,0x0000019d,0x61726170,0x0000006d,0x00030005,0x000001a0,0x00000065, + 0x00040005,0x000001a6,0x65646166,0x00000000,0x00050005,0x000001b2,0x4374756f,0x726f6c6f, + 0x00000000,0x00030047,0x0000001e,0x00000002,0x00050048,0x0000001e,0x00000000,0x00000023, + 0x00000000,0x00050048,0x0000001e,0x00000001,0x00000023,0x00000010,0x00050048,0x0000001e, + 0x00000002,0x00000023,0x00000020,0x00050048,0x0000001e,0x00000003,0x00000023,0x00000030, + 0x00050048,0x0000001e,0x00000004,0x00000023,0x00000040,0x00050048,0x0000001e,0x00000005, + 0x00000023,0x00000050,0x00050048,0x0000001e,0x00000006,0x00000023,0x00000060,0x00040047, + 0x00000082,0x00000021,0x00000000,0x00040047,0x00000082,0x00000022,0x00000000,0x00040047, + 0x0000012d,0x0000001e,0x00000000,0x00040047,0x000001b2,0x0000001e,0x00000000,0x00020013, + 0x00000002,0x00030021,0x00000003,0x00000002,0x00030016,0x00000006,0x00000020,0x00040017, + 0x00000007,0x00000006,0x00000002,0x00040020,0x00000008,0x00000007,0x00000007,0x00040020, + 0x00000009,0x00000007,0x00000006,0x00050021,0x0000000a,0x00000007,0x00000008,0x00000009, + 0x00040017,0x0000000f,0x00000006,0x00000003,0x00050021,0x00000010,0x0000000f,0x00000008, + 0x00000009,0x0004002b,0x00000006,0x0000001c,0x3f800000,0x00040017,0x0000001d,0x00000006, + 0x00000004,0x0009001e,0x0000001e,0x0000001d,0x0000001d,0x0000001d,0x0000001d,0x0000001d, + 0x0000001d,0x0000001d,0x00040020,0x0000001f,0x00000009,0x0000001e,0x0004003b,0x0000001f, + 0x00000020,0x00000009,0x00040015,0x00000021,0x00000020,0x00000001,0x0004002b,0x00000021, + 0x00000022,0x00000004,0x00040015,0x00000023,0x00000020,0x00000000,0x0004002b,0x00000023, + 0x00000024,0x00000000,0x00040020,0x00000025,0x00000009,0x00000006,0x0004002b,0x00000023, + 0x0000002b,0x00000001,0x0004002b,0x00000021,0x00000036,0x00000005,0x0004002b,0x00000023, + 0x00000037,0x00000002,0x0004002b,0x00000006,0x0000003a,0x3f000000,0x00020014,0x0000003b, + 0x0004002b,0x00000023,0x00000046,0x00000003,0x0004002b,0x00000006,0x00000055,0x3fc00000, + 0x0005002c,0x00000007,0x00000065,0x0000001c,0x0000001c,0x0004002b,0x00000006,0x0000006f, + 0x00000000,0x0005002c,0x00000007,0x00000070,0x0000006f,0x0000006f,0x00040017,0x00000071, + 0x0000003b,0x00000002,0x0006002c,0x0000000f,0x0000007d,0x0000006f,0x0000006f,0x0000006f, + 0x00090019,0x0000007f,0x00000006,0x00000001,0x00000000,0x00000000,0x00000000,0x00000001, + 0x00000000,0x0003001b,0x00000080,0x0000007f,0x00040020,0x00000081,0x00000000,0x00000080, + 0x0004003b,0x00000081,0x00000082,0x00000000,0x00040018,0x000000a1,0x0000000f,0x00000003, + 0x00040020,0x000000a2,0x00000007,0x000000a1,0x0004002b,0x00000021,0x000000a4,0x00000001, + 0x00040020,0x000000a5,0x00000009,0x0000001d,0x0004002b,0x00000021,0x000000a9,0x00000002, + 0x0004002b,0x00000021,0x000000ad,0x00000003,0x00040020,0x000000bf,0x00000007,0x0000000f, + 0x0004002b,0x00000006,0x000000c7,0xbf800000,0x0004002b,0x00000021,0x000000cc,0x00000006, + 0x0004002b,0x00000006,0x000000dc,0xb8d1b717,0x0004002b,0x00000006,0x000000e0,0x3c75c28f, + 0x0004002b,0x00000006,0x000000e1,0x3ca3d70a,0x0006002c,0x0000000f,0x000000e2,0x000000e0, + 0x000000e0,0x000000e1,0x00040020,0x00000122,0x00000007,0x0000003b,0x00040020,0x0000012c, + 0x00000001,0x00000007,0x0004003b,0x0000012c,0x0000012d,0x00000001,0x00040020,0x0000012e, + 0x00000001,0x00000006,0x0004002b,0x00000006,0x0000013d,0x40000000,0x0004002b,0x00000006, + 0x000001a7,0x3cf5c28f,0x00040020,0x000001b1,0x00000003,0x0000001d,0x0004003b,0x000001b1, + 0x000001b2,0x00000003,0x00050036,0x00000002,0x00000004,0x00000000,0x00000003,0x000200f8, + 0x00000005,0x0004003b,0x00000122,0x00000123,0x00000007,0x0004003b,0x00000009,0x00000127, + 0x00000007,0x0004003b,0x00000008,0x00000134,0x00000007,0x0004003b,0x00000008,0x00000136, + 0x00000007,0x0004003b,0x00000009,0x00000145,0x00000007,0x0004003b,0x00000009,0x00000147, + 0x00000007,0x0004003b,0x00000009,0x0000014d,0x00000007,0x0004003b,0x00000008,0x00000159, + 0x00000007,0x0004003b,0x00000009,0x0000015e,0x00000007,0x0004003b,0x00000008,0x00000161, + 0x00000007,0x0004003b,0x000000bf,0x00000172,0x00000007,0x0004003b,0x00000008,0x00000176, + 0x00000007,0x0004003b,0x00000009,0x00000178,0x00000007,0x0004003b,0x00000008,0x0000017a, + 0x00000007,0x0004003b,0x00000009,0x0000017b,0x00000007,0x0004003b,0x00000008,0x00000180, + 0x00000007,0x0004003b,0x00000009,0x00000182,0x00000007,0x0004003b,0x00000008,0x00000184, + 0x00000007,0x0004003b,0x00000009,0x00000185,0x00000007,0x0004003b,0x00000008,0x0000018d, + 0x00000007,0x0004003b,0x00000009,0x0000018f,0x00000007,0x0004003b,0x00000008,0x00000191, + 0x00000007,0x0004003b,0x00000009,0x00000192,0x00000007,0x0004003b,0x00000008,0x00000198, + 0x00000007,0x0004003b,0x00000009,0x0000019a,0x00000007,0x0004003b,0x00000008,0x0000019c, + 0x00000007,0x0004003b,0x00000009,0x0000019d,0x00000007,0x0004003b,0x00000008,0x000001a0, + 0x00000007,0x0004003b,0x00000009,0x000001a6,0x00000007,0x00060041,0x00000025,0x00000124, + 0x00000020,0x000000cc,0x00000024,0x0004003d,0x00000006,0x00000125,0x00000124,0x000500ba, + 0x0000003b,0x00000126,0x00000125,0x0000003a,0x0003003e,0x00000123,0x00000126,0x0004003d, + 0x0000003b,0x00000128,0x00000123,0x000400a8,0x0000003b,0x00000129,0x00000128,0x000300f7, + 0x0000012b,0x00000000,0x000400fa,0x00000129,0x0000012a,0x0000012b,0x000200f8,0x0000012a, + 0x00050041,0x0000012e,0x0000012f,0x0000012d,0x00000024,0x0004003d,0x00000006,0x00000130, + 0x0000012f,0x000500b8,0x0000003b,0x00000131,0x00000130,0x0000003a,0x000200f9,0x0000012b, + 0x000200f8,0x0000012b,0x000700f5,0x0000003b,0x00000132,0x00000128,0x00000005,0x00000131, + 0x0000012a,0x000600a9,0x00000006,0x00000133,0x00000132,0x0000006f,0x0000001c,0x0003003e, + 0x00000127,0x00000133,0x0004003d,0x0000003b,0x00000135,0x00000123,0x000300f7,0x00000138, + 0x00000000,0x000400fa,0x00000135,0x00000137,0x0000013a,0x000200f8,0x00000137,0x0004003d, + 0x00000007,0x00000139,0x0000012d,0x0003003e,0x00000136,0x00000139,0x000200f9,0x00000138, + 0x000200f8,0x0000013a,0x00050041,0x0000012e,0x0000013b,0x0000012d,0x00000024,0x0004003d, + 0x00000006,0x0000013c,0x0000013b,0x00050085,0x00000006,0x0000013e,0x0000013c,0x0000013d, + 0x0004003d,0x00000006,0x0000013f,0x00000127,0x00050083,0x00000006,0x00000140,0x0000013e, + 0x0000013f,0x00050041,0x0000012e,0x00000141,0x0000012d,0x0000002b,0x0004003d,0x00000006, + 0x00000142,0x00000141,0x00050050,0x00000007,0x00000143,0x00000140,0x00000142,0x0003003e, + 0x00000136,0x00000143,0x000200f9,0x00000138,0x000200f8,0x00000138,0x0004003d,0x00000007, + 0x00000144,0x00000136,0x0003003e,0x00000134,0x00000144,0x0004003d,0x0000003b,0x00000146, + 0x00000123,0x000300f7,0x00000149,0x00000000,0x000400fa,0x00000146,0x00000148,0x0000014a, + 0x000200f8,0x00000148,0x0003003e,0x00000147,0x0000003a,0x000200f9,0x00000149,0x000200f8, + 0x0000014a,0x0004003d,0x00000006,0x0000014b,0x00000127,0x000500b8,0x0000003b,0x0000014c, + 0x0000014b,0x0000003a,0x000300f7,0x0000014f,0x00000000,0x000400fa,0x0000014c,0x0000014e, + 0x00000152,0x000200f8,0x0000014e,0x00060041,0x00000025,0x00000150,0x00000020,0x00000036, + 0x00000024,0x0004003d,0x00000006,0x00000151,0x00000150,0x0003003e,0x0000014d,0x00000151, + 0x000200f9,0x0000014f,0x000200f8,0x00000152,0x00060041,0x00000025,0x00000153,0x00000020, + 0x00000036,0x00000024,0x0004003d,0x00000006,0x00000154,0x00000153,0x0004007f,0x00000006, + 0x00000155,0x00000154,0x0003003e,0x0000014d,0x00000155,0x000200f9,0x0000014f,0x000200f8, + 0x0000014f,0x0004003d,0x00000006,0x00000156,0x0000014d,0x00050081,0x00000006,0x00000157, + 0x0000003a,0x00000156,0x0003003e,0x00000147,0x00000157,0x000200f9,0x00000149,0x000200f8, + 0x00000149,0x0004003d,0x00000006,0x00000158,0x00000147,0x0003003e,0x00000145,0x00000158, + 0x0004003d,0x00000007,0x0000015a,0x00000134,0x0004003d,0x00000006,0x0000015b,0x00000145, + 0x00050050,0x00000007,0x0000015c,0x0000015b,0x0000003a,0x00050083,0x00000007,0x0000015d, + 0x0000015a,0x0000015c,0x0003003e,0x00000159,0x0000015d,0x00060041,0x00000025,0x0000015f, + 0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006,0x00000160,0x0000015f,0x0003003e, + 0x0000015e,0x00000160,0x00050041,0x00000009,0x00000162,0x00000159,0x00000024,0x0004003d, + 0x00000006,0x00000163,0x00000162,0x00060041,0x00000025,0x00000164,0x00000020,0x00000036, + 0x00000046,0x0004003d,0x00000006,0x00000165,0x00000164,0x00050085,0x00000006,0x00000166, + 0x00000163,0x00000165,0x00050041,0x00000009,0x00000167,0x00000159,0x0000002b,0x0004003d, + 0x00000006,0x00000168,0x00000167,0x00050050,0x00000007,0x00000169,0x00000166,0x00000168, + 0x0005008e,0x00000007,0x0000016a,0x00000169,0x0000013d,0x0004003d,0x00000006,0x0000016b, + 0x0000015e,0x0005008e,0x00000007,0x0000016c,0x0000016a,0x0000016b,0x0003003e,0x00000161, + 0x0000016c,0x00060041,0x00000025,0x0000016d,0x00000020,0x00000022,0x00000046,0x0004003d, + 0x00000006,0x0000016e,0x0000016d,0x000500ba,0x0000003b,0x0000016f,0x0000016e,0x0000006f, + 0x000300f7,0x00000171,0x00000000,0x000400fa,0x0000016f,0x00000170,0x00000197,0x000200f8, + 0x00000170,0x00060041,0x00000025,0x00000173,0x00000020,0x00000022,0x00000046,0x0004003d, + 0x00000006,0x00000174,0x00000173,0x00050083,0x00000006,0x00000175,0x0000001c,0x00000174, + 0x0004003d,0x00000007,0x00000177,0x00000161,0x0003003e,0x00000176,0x00000177,0x0003003e, + 0x00000178,0x00000175,0x00060039,0x00000007,0x00000179,0x0000000d,0x00000176,0x00000178, + 0x0003003e,0x0000017a,0x00000179,0x0004003d,0x00000006,0x0000017c,0x00000127,0x0003003e, + 0x0000017b,0x0000017c,0x00060039,0x0000000f,0x0000017d,0x00000013,0x0000017a,0x0000017b, + 0x00050051,0x00000006,0x0000017e,0x0000017d,0x00000000,0x00050041,0x00000009,0x0000017f, + 0x00000172,0x00000024,0x0003003e,0x0000017f,0x0000017e,0x0004003d,0x00000007,0x00000181, + 0x00000161,0x0003003e,0x00000180,0x00000181,0x0003003e,0x00000182,0x0000001c,0x00060039, + 0x00000007,0x00000183,0x0000000d,0x00000180,0x00000182,0x0003003e,0x00000184,0x00000183, + 0x0004003d,0x00000006,0x00000186,0x00000127,0x0003003e,0x00000185,0x00000186,0x00060039, + 0x0000000f,0x00000187,0x00000013,0x00000184,0x00000185,0x00050051,0x00000006,0x00000188, + 0x00000187,0x00000001,0x00050041,0x00000009,0x00000189,0x00000172,0x0000002b,0x0003003e, + 0x00000189,0x00000188,0x00060041,0x00000025,0x0000018a,0x00000020,0x00000022,0x00000046, + 0x0004003d,0x00000006,0x0000018b,0x0000018a,0x00050081,0x00000006,0x0000018c,0x0000001c, + 0x0000018b,0x0004003d,0x00000007,0x0000018e,0x00000161,0x0003003e,0x0000018d,0x0000018e, + 0x0003003e,0x0000018f,0x0000018c,0x00060039,0x00000007,0x00000190,0x0000000d,0x0000018d, + 0x0000018f,0x0003003e,0x00000191,0x00000190,0x0004003d,0x00000006,0x00000193,0x00000127, + 0x0003003e,0x00000192,0x00000193,0x00060039,0x0000000f,0x00000194,0x00000013,0x00000191, + 0x00000192,0x00050051,0x00000006,0x00000195,0x00000194,0x00000002,0x00050041,0x00000009, + 0x00000196,0x00000172,0x00000037,0x0003003e,0x00000196,0x00000195,0x000200f9,0x00000171, + 0x000200f8,0x00000197,0x0004003d,0x00000007,0x00000199,0x00000161,0x0003003e,0x00000198, + 0x00000199,0x0003003e,0x0000019a,0x0000001c,0x00060039,0x00000007,0x0000019b,0x0000000d, + 0x00000198,0x0000019a,0x0003003e,0x0000019c,0x0000019b,0x0004003d,0x00000006,0x0000019e, + 0x00000127,0x0003003e,0x0000019d,0x0000019e,0x00060039,0x0000000f,0x0000019f,0x00000013, + 0x0000019c,0x0000019d,0x0003003e,0x00000172,0x0000019f,0x000200f9,0x00000171,0x000200f8, + 0x00000171,0x0004003d,0x00000007,0x000001a1,0x00000134,0x0004003d,0x00000007,0x000001a2, + 0x00000134,0x00050050,0x00000007,0x000001a3,0x0000001c,0x0000001c,0x00050083,0x00000007, + 0x000001a4,0x000001a3,0x000001a2,0x0007000c,0x00000007,0x000001a5,0x00000001,0x00000025, + 0x000001a1,0x000001a4,0x0003003e,0x000001a0,0x000001a5,0x00050041,0x00000009,0x000001a8, + 0x000001a0,0x00000024,0x0004003d,0x00000006,0x000001a9,0x000001a8,0x00060041,0x00000025, + 0x000001aa,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x000001ab,0x000001aa, + 0x00050085,0x00000006,0x000001ac,0x000001a9,0x000001ab,0x00050041,0x00000009,0x000001ad, + 0x000001a0,0x0000002b,0x0004003d,0x00000006,0x000001ae,0x000001ad,0x0007000c,0x00000006, + 0x000001af,0x00000001,0x00000025,0x000001ac,0x000001ae,0x0008000c,0x00000006,0x000001b0, + 0x00000001,0x00000031,0x0000006f,0x000001a7,0x000001af,0x0003003e,0x000001a6,0x000001b0, + 0x0004003d,0x0000000f,0x000001b3,0x00000172,0x0004003d,0x00000006,0x000001b4,0x000001a6, + 0x0005008e,0x0000000f,0x000001b5,0x000001b3,0x000001b4,0x00050051,0x00000006,0x000001b6, + 0x000001b5,0x00000000,0x00050051,0x00000006,0x000001b7,0x000001b5,0x00000001,0x00050051, + 0x00000006,0x000001b8,0x000001b5,0x00000002,0x00070050,0x0000001d,0x000001b9,0x000001b6, + 0x000001b7,0x000001b8,0x0000001c,0x0003003e,0x000001b2,0x000001b9,0x000100fd,0x00010038, + 0x00050036,0x00000007,0x0000000d,0x00000000,0x0000000a,0x00030037,0x00000008,0x0000000b, + 0x00030037,0x00000009,0x0000000c,0x000200f8,0x0000000e,0x0004003b,0x00000009,0x00000015, + 0x00000007,0x0004003d,0x00000007,0x00000016,0x0000000b,0x0004003d,0x00000007,0x00000017, + 0x0000000b,0x00050094,0x00000006,0x00000018,0x00000016,0x00000017,0x0003003e,0x00000015, + 0x00000018,0x0004003d,0x00000007,0x00000019,0x0000000b,0x0004003d,0x00000006,0x0000001a, + 0x0000000c,0x0005008e,0x00000007,0x0000001b,0x00000019,0x0000001a,0x00060041,0x00000025, + 0x00000026,0x00000020,0x00000022,0x00000024,0x0004003d,0x00000006,0x00000027,0x00000026, + 0x0004003d,0x00000006,0x00000028,0x00000015,0x00050085,0x00000006,0x00000029,0x00000027, + 0x00000028,0x00050081,0x00000006,0x0000002a,0x0000001c,0x00000029,0x00060041,0x00000025, + 0x0000002c,0x00000020,0x00000022,0x0000002b,0x0004003d,0x00000006,0x0000002d,0x0000002c, + 0x0004003d,0x00000006,0x0000002e,0x00000015,0x00050085,0x00000006,0x0000002f,0x0000002d, + 0x0000002e,0x0004003d,0x00000006,0x00000030,0x00000015,0x00050085,0x00000006,0x00000031, + 0x0000002f,0x00000030,0x00050081,0x00000006,0x00000032,0x0000002a,0x00000031,0x0005008e, + 0x00000007,0x00000033,0x0000001b,0x00000032,0x000200fe,0x00000033,0x00010038,0x00050036, + 0x0000000f,0x00000013,0x00000000,0x00000010,0x00030037,0x00000008,0x00000011,0x00030037, + 0x00000009,0x00000012,0x000200f8,0x00000014,0x0004003b,0x00000009,0x0000003f,0x00000007, + 0x0004003b,0x00000008,0x00000042,0x00000007,0x0004003b,0x00000008,0x00000059,0x00000007, + 0x0004003b,0x000000a2,0x000000a3,0x00000007,0x0004003b,0x000000bf,0x000000c0,0x00000007, + 0x0004003b,0x000000bf,0x000000cb,0x00000007,0x0004003b,0x00000009,0x000000e4,0x00000007, + 0x0004003b,0x000000bf,0x000000f3,0x00000007,0x0004003b,0x00000009,0x000000f9,0x00000007, + 0x0004003b,0x00000009,0x000000fc,0x00000007,0x0004003b,0x00000008,0x00000101,0x00000007, + 0x00060041,0x00000025,0x00000038,0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006, + 0x00000039,0x00000038,0x000500ba,0x0000003b,0x0000003c,0x00000039,0x0000003a,0x000300f7, + 0x0000003e,0x00000000,0x000400fa,0x0000003c,0x0000003d,0x0000003e,0x000200f8,0x0000003d, + 0x00060041,0x00000025,0x00000040,0x00000020,0x00000022,0x00000037,0x0004003d,0x00000006, + 0x00000041,0x00000040,0x0003003e,0x0000003f,0x00000041,0x00050041,0x00000009,0x00000043, + 0x00000011,0x00000024,0x0004003d,0x00000006,0x00000044,0x00000043,0x0004003d,0x00000006, + 0x00000045,0x0000003f,0x00060041,0x00000025,0x00000047,0x00000020,0x00000036,0x00000046, + 0x0004003d,0x00000006,0x00000048,0x00000047,0x00050085,0x00000006,0x00000049,0x00000045, + 0x00000048,0x00050088,0x00000006,0x0000004a,0x00000044,0x00000049,0x00050041,0x00000009, + 0x0000004b,0x00000011,0x0000002b,0x0004003d,0x00000006,0x0000004c,0x0000004b,0x0004003d, + 0x00000006,0x0000004d,0x0000003f,0x00050088,0x00000006,0x0000004e,0x0000004c,0x0000004d, + 0x00050050,0x00000007,0x0000004f,0x0000004a,0x0000004e,0x0005008e,0x00000007,0x00000050, + 0x0000004f,0x0000003a,0x00050050,0x00000007,0x00000051,0x0000003a,0x0000003a,0x00050081, + 0x00000007,0x00000052,0x00000050,0x00000051,0x0003003e,0x00000042,0x00000052,0x00060041, + 0x00000025,0x00000053,0x00000020,0x00000036,0x00000037,0x0004003d,0x00000006,0x00000054, + 0x00000053,0x000500ba,0x0000003b,0x00000056,0x00000054,0x00000055,0x000300f7,0x00000058, + 0x00000000,0x000400fa,0x00000056,0x00000057,0x00000058,0x000200f8,0x00000057,0x00060041, + 0x00000025,0x0000005a,0x00000020,0x00000036,0x00000046,0x0004003d,0x00000006,0x0000005b, + 0x0000005a,0x00060041,0x00000025,0x0000005c,0x00000020,0x00000036,0x0000002b,0x0004003d, + 0x00000006,0x0000005d,0x0000005c,0x00050088,0x00000006,0x0000005e,0x0000005b,0x0000005d, + 0x00060041,0x00000025,0x0000005f,0x00000020,0x00000036,0x0000002b,0x0004003d,0x00000006, + 0x00000060,0x0000005f,0x00060041,0x00000025,0x00000061,0x00000020,0x00000036,0x00000046, + 0x0004003d,0x00000006,0x00000062,0x00000061,0x00050088,0x00000006,0x00000063,0x00000060, + 0x00000062,0x00050050,0x00000007,0x00000064,0x0000005e,0x00000063,0x0007000c,0x00000007, + 0x00000066,0x00000001,0x00000028,0x00000064,0x00000065,0x0003003e,0x00000059,0x00000066, + 0x0004003d,0x00000007,0x00000067,0x00000042,0x00050050,0x00000007,0x00000068,0x0000003a, + 0x0000003a,0x00050083,0x00000007,0x00000069,0x00000067,0x00000068,0x0004003d,0x00000007, + 0x0000006a,0x00000059,0x00050085,0x00000007,0x0000006b,0x00000069,0x0000006a,0x00050050, + 0x00000007,0x0000006c,0x0000003a,0x0000003a,0x00050081,0x00000007,0x0000006d,0x0000006b, + 0x0000006c,0x0003003e,0x00000042,0x0000006d,0x0004003d,0x00000007,0x0000006e,0x00000042, + 0x000500b8,0x00000071,0x00000072,0x0000006e,0x00000070,0x0004009a,0x0000003b,0x00000073, + 0x00000072,0x000400a8,0x0000003b,0x00000074,0x00000073,0x000300f7,0x00000076,0x00000000, + 0x000400fa,0x00000074,0x00000075,0x00000076,0x000200f8,0x00000075,0x0004003d,0x00000007, + 0x00000077,0x00000042,0x000500ba,0x00000071,0x00000078,0x00000077,0x00000065,0x0004009a, + 0x0000003b,0x00000079,0x00000078,0x000200f9,0x00000076,0x000200f8,0x00000076,0x000700f5, + 0x0000003b,0x0000007a,0x00000073,0x00000057,0x00000079,0x00000075,0x000300f7,0x0000007c, + 0x00000000,0x000400fa,0x0000007a,0x0000007b,0x0000007c,0x000200f8,0x0000007b,0x000200fe, + 0x0000007d,0x000200f8,0x0000007c,0x0004003d,0x00000080,0x00000083,0x00000082,0x0004003d, + 0x00000007,0x00000084,0x00000042,0x00050057,0x0000001d,0x00000085,0x00000083,0x00000084, + 0x0008004f,0x0000000f,0x00000086,0x00000085,0x00000085,0x00000000,0x00000001,0x00000002, + 0x000200fe,0x00000086,0x000200f8,0x00000058,0x0004003d,0x00000007,0x00000088,0x00000042, + 0x000500b8,0x00000071,0x00000089,0x00000088,0x00000070,0x0004009a,0x0000003b,0x0000008a, + 0x00000089,0x000400a8,0x0000003b,0x0000008b,0x0000008a,0x000300f7,0x0000008d,0x00000000, + 0x000400fa,0x0000008b,0x0000008c,0x0000008d,0x000200f8,0x0000008c,0x0004003d,0x00000007, + 0x0000008e,0x00000042,0x000500ba,0x00000071,0x0000008f,0x0000008e,0x00000065,0x0004009a, + 0x0000003b,0x00000090,0x0000008f,0x000200f9,0x0000008d,0x000200f8,0x0000008d,0x000700f5, + 0x0000003b,0x00000091,0x0000008a,0x00000058,0x00000090,0x0000008c,0x000300f7,0x00000093, + 0x00000000,0x000400fa,0x00000091,0x00000092,0x00000093,0x000200f8,0x00000092,0x000200fe, + 0x0000007d,0x000200f8,0x00000093,0x0004003d,0x00000080,0x00000095,0x00000082,0x00050041, + 0x00000009,0x00000096,0x00000042,0x00000024,0x0004003d,0x00000006,0x00000097,0x00000096, + 0x0004003d,0x00000006,0x00000098,0x00000012,0x00050081,0x00000006,0x00000099,0x00000097, + 0x00000098,0x00050085,0x00000006,0x0000009a,0x00000099,0x0000003a,0x00050041,0x00000009, + 0x0000009b,0x00000042,0x0000002b,0x0004003d,0x00000006,0x0000009c,0x0000009b,0x00050050, + 0x00000007,0x0000009d,0x0000009a,0x0000009c,0x00050057,0x0000001d,0x0000009e,0x00000095, + 0x0000009d,0x0008004f,0x0000000f,0x0000009f,0x0000009e,0x0000009e,0x00000000,0x00000001, + 0x00000002,0x000200fe,0x0000009f,0x000200f8,0x0000003e,0x00050041,0x000000a5,0x000000a6, + 0x00000020,0x000000a4,0x0004003d,0x0000001d,0x000000a7,0x000000a6,0x0008004f,0x0000000f, + 0x000000a8,0x000000a7,0x000000a7,0x00000000,0x00000001,0x00000002,0x00050041,0x000000a5, + 0x000000aa,0x00000020,0x000000a9,0x0004003d,0x0000001d,0x000000ab,0x000000aa,0x0008004f, + 0x0000000f,0x000000ac,0x000000ab,0x000000ab,0x00000000,0x00000001,0x00000002,0x00050041, + 0x000000a5,0x000000ae,0x00000020,0x000000ad,0x0004003d,0x0000001d,0x000000af,0x000000ae, + 0x0008004f,0x0000000f,0x000000b0,0x000000af,0x000000af,0x00000000,0x00000001,0x00000002, + 0x00050051,0x00000006,0x000000b1,0x000000a8,0x00000000,0x00050051,0x00000006,0x000000b2, + 0x000000a8,0x00000001,0x00050051,0x00000006,0x000000b3,0x000000a8,0x00000002,0x00050051, + 0x00000006,0x000000b4,0x000000ac,0x00000000,0x00050051,0x00000006,0x000000b5,0x000000ac, + 0x00000001,0x00050051,0x00000006,0x000000b6,0x000000ac,0x00000002,0x00050051,0x00000006, + 0x000000b7,0x000000b0,0x00000000,0x00050051,0x00000006,0x000000b8,0x000000b0,0x00000001, + 0x00050051,0x00000006,0x000000b9,0x000000b0,0x00000002,0x00060050,0x0000000f,0x000000ba, + 0x000000b1,0x000000b2,0x000000b3,0x00060050,0x0000000f,0x000000bb,0x000000b4,0x000000b5, + 0x000000b6,0x00060050,0x0000000f,0x000000bc,0x000000b7,0x000000b8,0x000000b9,0x00060050, + 0x000000a1,0x000000bd,0x000000ba,0x000000bb,0x000000bc,0x00040054,0x000000a1,0x000000be, + 0x000000bd,0x0003003e,0x000000a3,0x000000be,0x0004003d,0x000000a1,0x000000c1,0x000000a3, + 0x00050041,0x00000009,0x000000c2,0x00000011,0x00000024,0x0004003d,0x00000006,0x000000c3, + 0x000000c2,0x00050041,0x00000009,0x000000c4,0x00000011,0x0000002b,0x0004003d,0x00000006, + 0x000000c5,0x000000c4,0x0004007f,0x00000006,0x000000c6,0x000000c5,0x00060050,0x0000000f, + 0x000000c8,0x000000c3,0x000000c6,0x000000c7,0x0006000c,0x0000000f,0x000000c9,0x00000001, + 0x00000045,0x000000c8,0x00050091,0x0000000f,0x000000ca,0x000000c1,0x000000c9,0x0003003e, + 0x000000c0,0x000000ca,0x00050041,0x000000a5,0x000000cd,0x00000020,0x000000cc,0x0004003d, + 0x0000001d,0x000000ce,0x000000cd,0x0008004f,0x0000000f,0x000000cf,0x000000ce,0x000000ce, + 0x00000001,0x00000002,0x00000003,0x0004003d,0x000000a1,0x000000d0,0x000000a3,0x0004003d, + 0x00000006,0x000000d1,0x00000012,0x000500b8,0x0000003b,0x000000d2,0x000000d1,0x0000003a, + 0x000600a9,0x00000006,0x000000d3,0x000000d2,0x000000c7,0x0000001c,0x00060041,0x00000025, + 0x000000d4,0x00000020,0x000000a4,0x00000046,0x0004003d,0x00000006,0x000000d5,0x000000d4, + 0x00050085,0x00000006,0x000000d6,0x000000d3,0x000000d5,0x00060050,0x0000000f,0x000000d7, + 0x000000d6,0x0000006f,0x0000006f,0x00050091,0x0000000f,0x000000d8,0x000000d0,0x000000d7, + 0x00050081,0x0000000f,0x000000d9,0x000000cf,0x000000d8,0x0003003e,0x000000cb,0x000000d9, + 0x00050041,0x00000009,0x000000da,0x000000c0,0x00000037,0x0004003d,0x00000006,0x000000db, + 0x000000da,0x000500ba,0x0000003b,0x000000dd,0x000000db,0x000000dc,0x000300f7,0x000000df, + 0x00000000,0x000400fa,0x000000dd,0x000000de,0x000000df,0x000200f8,0x000000de,0x000200fe, + 0x000000e2,0x000200f8,0x000000df,0x00060041,0x00000025,0x000000e5,0x00000020,0x000000a9, + 0x00000046,0x0004003d,0x00000006,0x000000e6,0x000000e5,0x0004007f,0x00000006,0x000000e7, + 0x000000e6,0x00050041,0x00000009,0x000000e8,0x000000cb,0x00000037,0x0004003d,0x00000006, + 0x000000e9,0x000000e8,0x00050083,0x00000006,0x000000ea,0x000000e7,0x000000e9,0x00050041, + 0x00000009,0x000000eb,0x000000c0,0x00000037,0x0004003d,0x00000006,0x000000ec,0x000000eb, + 0x00050088,0x00000006,0x000000ed,0x000000ea,0x000000ec,0x0003003e,0x000000e4,0x000000ed, + 0x0004003d,0x00000006,0x000000ee,0x000000e4,0x000500bc,0x0000003b,0x000000ef,0x000000ee, + 0x0000006f,0x000300f7,0x000000f1,0x00000000,0x000400fa,0x000000ef,0x000000f0,0x000000f1, + 0x000200f8,0x000000f0,0x000200fe,0x000000e2,0x000200f8,0x000000f1,0x0004003d,0x0000000f, + 0x000000f4,0x000000cb,0x0004003d,0x0000000f,0x000000f5,0x000000c0,0x0004003d,0x00000006, + 0x000000f6,0x000000e4,0x0005008e,0x0000000f,0x000000f7,0x000000f5,0x000000f6,0x00050081, + 0x0000000f,0x000000f8,0x000000f4,0x000000f7,0x0003003e,0x000000f3,0x000000f8,0x00060041, + 0x00000025,0x000000fa,0x00000020,0x000000ad,0x00000046,0x0004003d,0x00000006,0x000000fb, + 0x000000fa,0x0003003e,0x000000f9,0x000000fb,0x0004003d,0x00000006,0x000000fd,0x000000f9, + 0x00060041,0x00000025,0x000000fe,0x00000020,0x00000036,0x0000002b,0x0004003d,0x00000006, + 0x000000ff,0x000000fe,0x00050088,0x00000006,0x00000100,0x000000fd,0x000000ff,0x0003003e, + 0x000000fc,0x00000100,0x00050041,0x00000009,0x00000102,0x000000f3,0x00000024,0x0004003d, + 0x00000006,0x00000103,0x00000102,0x0004003d,0x00000006,0x00000104,0x000000f9,0x00050088, + 0x00000006,0x00000105,0x00000103,0x00000104,0x00050041,0x00000009,0x00000106,0x000000f3, + 0x0000002b,0x0004003d,0x00000006,0x00000107,0x00000106,0x0004007f,0x00000006,0x00000108, + 0x00000107,0x0004003d,0x00000006,0x00000109,0x000000fc,0x00050088,0x00000006,0x0000010a, + 0x00000108,0x00000109,0x00050050,0x00000007,0x0000010b,0x00000105,0x0000010a,0x0005008e, + 0x00000007,0x0000010c,0x0000010b,0x0000003a,0x00050050,0x00000007,0x0000010d,0x0000003a, + 0x0000003a,0x00050081,0x00000007,0x0000010e,0x0000010c,0x0000010d,0x0003003e,0x00000101, + 0x0000010e,0x0004003d,0x00000007,0x0000010f,0x00000101,0x000500b8,0x00000071,0x00000110, + 0x0000010f,0x00000070,0x0004009a,0x0000003b,0x00000111,0x00000110,0x000400a8,0x0000003b, + 0x00000112,0x00000111,0x000300f7,0x00000114,0x00000000,0x000400fa,0x00000112,0x00000113, + 0x00000114,0x000200f8,0x00000113,0x0004003d,0x00000007,0x00000115,0x00000101,0x000500ba, + 0x00000071,0x00000116,0x00000115,0x00000065,0x0004009a,0x0000003b,0x00000117,0x00000116, + 0x000200f9,0x00000114,0x000200f8,0x00000114,0x000700f5,0x0000003b,0x00000118,0x00000111, + 0x000000f1,0x00000117,0x00000113,0x000300f7,0x0000011a,0x00000000,0x000400fa,0x00000118, + 0x00000119,0x0000011a,0x000200f8,0x00000119,0x000200fe,0x000000e2,0x000200f8,0x0000011a, + 0x0004003d,0x00000080,0x0000011c,0x00000082,0x0004003d,0x00000007,0x0000011d,0x00000101, + 0x00050057,0x0000001d,0x0000011e,0x0000011c,0x0000011d,0x0008004f,0x0000000f,0x0000011f, + 0x0000011e,0x0000011e,0x00000000,0x00000001,0x00000002,0x000200fe,0x0000011f,0x00010038 }; diff --git a/app/src/main/cpp/waylandcomp/src/spatialpose.c b/app/src/main/cpp/waylandcomp/src/spatialpose.c new file mode 100644 index 0000000000..48f56905ae --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/spatialpose.c @@ -0,0 +1,59 @@ +#define _POSIX_C_SOURCE 200809L +#include "spatialpose_shm.h" +#include +#include +#include +#include +#include +#include +#include + +static pthread_mutex_t spatial_lock = PTHREAD_MUTEX_INITIALIZER; +static struct droiddeck_spatialpose *shared; + +JNIEXPORT jboolean JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetSpatialFile( + JNIEnv *env, jclass clazz, jstring path) { + (void)clazz; + pthread_mutex_lock(&spatial_lock); + if (!shared && path) { + const char *name = (*env)->GetStringUTFChars(env, path, NULL); + if (name) { + int fd = open(name, O_RDWR | O_CREAT | O_CLOEXEC, 0600); + (*env)->ReleaseStringUTFChars(env, path, name); + if (fd >= 0) { + if (ftruncate(fd, sizeof(*shared)) == 0) { + void *p = mmap(NULL, sizeof(*shared), PROT_READ | PROT_WRITE, MAP_SHARED, fd, 0); + if (p != MAP_FAILED) { + shared = p; + memset(shared, 0, sizeof(*shared)); + shared->magic = DROIDDECK_SPATIALPOSE_MAGIC; + shared->version = DROIDDECK_SPATIALPOSE_VERSION; + shared->size = sizeof(*shared); + } + } + close(fd); + } + } + } + jboolean ready = shared != NULL; + pthread_mutex_unlock(&spatial_lock); + return ready; +} + +JNIEXPORT void JNICALL Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativePublishSpatial( + JNIEnv *env, jclass clazz, jobject buffer) { + (void)clazz; + if (!buffer || (*env)->GetDirectBufferCapacity(env, buffer) != sizeof(*shared)) return; + const struct droiddeck_spatialpose *src = (*env)->GetDirectBufferAddress(env, buffer); + if (!src || src->magic != DROIDDECK_SPATIALPOSE_MAGIC || src->version != DROIDDECK_SPATIALPOSE_VERSION || + src->size != sizeof(*shared)) return; + pthread_mutex_lock(&spatial_lock); + if (shared) { + unsigned seq = __atomic_load_n(&shared->seq, __ATOMIC_RELAXED); + __atomic_store_n(&shared->seq, seq | 1u, __ATOMIC_RELAXED); + __atomic_thread_fence(__ATOMIC_RELEASE); + memcpy((char *)shared + 16, (const char *)src + 16, sizeof(*shared) - 16); + __atomic_store_n(&shared->seq, (seq | 1u) + 1u, __ATOMIC_RELEASE); + } + pthread_mutex_unlock(&spatial_lock); +} diff --git a/app/src/main/cpp/waylandcomp/src/spatialpose_shm.h b/app/src/main/cpp/waylandcomp/src/spatialpose_shm.h new file mode 100644 index 0000000000..099188736b --- /dev/null +++ b/app/src/main/cpp/waylandcomp/src/spatialpose_shm.h @@ -0,0 +1,33 @@ +#ifndef DROIDDECK_SPATIALPOSE_SHM_H +#define DROIDDECK_SPATIALPOSE_SHM_H +#include +#define DROIDDECK_SPATIALPOSE_MAGIC 0x53504444u +#define DROIDDECK_SPATIALPOSE_VERSION 4u +#define DROIDDECK_SPATIALPOSE_FILE "droiddeck-spatialpose" +enum { DD_SPATIAL_ACTIVE = 1u, DD_SPATIAL_HANDS = 2u, DD_SPATIAL_JOYCONS = 4u, DD_SPATIAL_STEADY_AIM = 8u, DD_SPATIAL_VALID = 1u }; +enum { DD_SPATIAL_TRIGGER_VALID = 2u, DD_SPATIAL_GRIP_VALID = 4u }; +struct dd_spatial_pose { + int64_t time_ns; + float position[3]; + float rotation[4]; + uint32_t flags; +}; +struct dd_spatial_hand { + struct dd_spatial_pose pose; + float trigger; + uint32_t grip; +}; +struct droiddeck_spatialpose { + uint32_t magic, version, size, seq; + uint64_t connection, origin; + uint32_t flags, input_epochs; + struct dd_spatial_pose head; + struct dd_spatial_hand hands[2]; +}; +#ifdef __cplusplus +static_assert(sizeof(dd_spatial_pose) == 40, "spatial pose ABI"); +static_assert(sizeof(droiddeck_spatialpose) == 176, "spatial snapshot ABI"); +#else +_Static_assert(sizeof(struct droiddeck_spatialpose) == 176, "spatial snapshot ABI"); +#endif +#endif diff --git a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c index 78cfb33f4a..6a407088bb 100644 --- a/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c +++ b/app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c @@ -649,3 +649,14 @@ Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeRaisePriority(JNIEnv int after = getpriority(PRIO_PROCESS, (id_t)tid); return after == -1 && errno != 0 ? 100 : after; } + +JNIEXPORT void JNICALL +Java_com_droiddeck_launcher_wayland_WaylandCompositor_nativeSetCardboardSpatialPose(JNIEnv *env, jclass clazz, + jfloatArray rot, jfloatArray pos, jboolean live) { + (void)clazz; + if (!rot || !pos || (*env)->GetArrayLength(env, rot) != 9 || (*env)->GetArrayLength(env, pos) != 3) return; + float m[9], p[3]; + (*env)->GetFloatArrayRegion(env, rot, 0, 9, m); + (*env)->GetFloatArrayRegion(env, pos, 0, 3, p); + vkp_cardboard_set_spatial_pose(m, p, live ? 1 : 0); +} diff --git a/app/src/main/java/com/droiddeck/launcher/App.kt b/app/src/main/java/com/droiddeck/launcher/App.kt index 8de9e1e81c..e0abe387d8 100644 --- a/app/src/main/java/com/droiddeck/launcher/App.kt +++ b/app/src/main/java/com/droiddeck/launcher/App.kt @@ -16,10 +16,11 @@ class App : Application() { override fun onCreate() { super.onCreate() - // The restart screen must not initialize USB, guest processes, or another graphics context. - val process = (getSystemService(ACTIVITY_SERVICE) as android.app.ActivityManager) - .runningAppProcesses?.firstOrNull { it.pid == android.os.Process.myPid() }?.processName - if (process == "$packageName:vr_recovery") return + // Helper processes must not initialize the main USB provider or guest graphics context. + val process = if (android.os.Build.VERSION.SDK_INT >= 28) Application.getProcessName() + else (getSystemService(ACTIVITY_SERVICE) as android.app.ActivityManager) + .runningAppProcesses?.firstOrNull { it.pid == android.os.Process.myPid() }?.processName + if (process == "$packageName:vr_recovery" || process == "$packageName:rgb_diagnostic") return CrashHandler.install(this) com.droiddeck.launcher.session.QuestExperimental.initialize(this) com.droiddeck.launcher.session.SessionPrefs.settleGpuDriverMode(this) @@ -27,6 +28,7 @@ class App : Application() { com.droiddeck.launcher.core.DownloadSource.init(this) GpuClockPin.clearLeftover(this) com.droiddeck.launcher.glasses.Glasses.init(this) + com.droiddeck.launcher.glasses.GlassesMenuMirror.initialize(this) BwrapSpawner.start(this) com.droiddeck.launcher.frontend.GameFileSync.start(this) com.droiddeck.launcher.stores.StoresState.init(this) diff --git a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt index 7c9448a311..6d5829daab 100644 --- a/app/src/main/java/com/droiddeck/launcher/MainActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/MainActivity.kt @@ -1209,7 +1209,9 @@ class MainActivity : ComponentActivity() { } private fun playSteamVr() { - if (com.droiddeck.launcher.handtracking.HandTracking.wanted(this)) placementCheck = true + val tracking = com.droiddeck.launcher.glasses.Glasses.settings.value + if (!com.droiddeck.launcher.glasses.Glasses.state.value.usesSpatialControllers(tracking) && + com.droiddeck.launcher.handtracking.HandTracking.wanted(this)) placementCheck = true else startSteamSession(steamVr = true) } @@ -1929,6 +1931,9 @@ class MainActivity : ComponentActivity() { val scanGeneration = ++libraryScanGeneration val artRefreshesAtStart = HashMap(steamArtRefreshes) if (shortcutPicker) shortcutLibraryScanning = true + if (SessionPrefs.steamClientArch(this) == "x86_64" && !OfflineMode.enabled(this)) { + Thread({ com.droiddeck.launcher.session.FexCatalog.refresh(this) }, "fex-catalog").start() + } Thread({ val emus = Library.emulators(this) { id -> DesktopCatalog.installed(this, id) != null } ui.post { if (scanGeneration == libraryScanGeneration) emulatorList = emus } diff --git a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt index cc1bc77a70..d78defc0df 100644 --- a/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt +++ b/app/src/main/java/com/droiddeck/launcher/SessionActivity.kt @@ -56,6 +56,8 @@ import com.droiddeck.launcher.gpu.HeadTracker import com.droiddeck.launcher.glasses.Glasses import com.droiddeck.launcher.glasses.GlassesScreen import com.droiddeck.launcher.glasses.GlassesRendering +import com.droiddeck.launcher.glasses.SpatialTracking +import com.droiddeck.launcher.glasses.TrackingRecovery import kotlinx.coroutines.cancel import kotlinx.coroutines.launch import com.droiddeck.launcher.gpu.SteamVr @@ -306,11 +308,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private var glassesSettings by mutableStateOf(Glasses.settings.value) private var glassesScreen: GlassesScreen? = null private var glassesOutputActive by mutableStateOf(false) + private var trackingRecovery by mutableStateOf(null) private var glasses3dForVr = false private var ended = false private var glassesPresent = false private var steamVrAutoTried = false private var steamVrInstallTried = false + @Volatile private var steamVrRequestGeneration = 0L private var headTracking by mutableStateOf(false) private var glassesSlot by mutableStateOf(0) private var glassesKey: List = emptyList() @@ -412,6 +416,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } else if (intent.getBooleanExtra(EXTRA_STEAMVR, false) && SessionState.mode == SessionService.MODE_STEAM) { SessionState.steamVr = true } + if (SessionState.steamVr) Glasses.prepareSteamVrStart() if (intent.action == SessionService.ACTION_AGENT_START) { SessionEvents.record("agent.start_requested", mapOf("mode" to SessionState.mode)) } @@ -519,9 +524,25 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { sessionOverlay = createSessionOverlay() root.addView(sessionOverlay) setContentView(root) - glassesScope.launch { Glasses.state.collect { glasses = it; onGlassesChanged() } } - glassesScope.launch { Glasses.settings.collect { glassesSettings = it; onGlassesChanged() } } + glassesScope.launch { Glasses.state.collect { + glasses = it + onGlassesChanged() + updateJoyConTracking() + updateHandCamera() + } } + glassesScope.launch { Glasses.settings.collect { + glassesSettings = it + onGlassesChanged() + updateJoyConTracking() + updateHandCamera() + } } glassesScope.launch { com.droiddeck.launcher.handtracking.HandTracking.settings.collect { updateHandCamera() } } + glassesScope.launch { + while (true) { + updateTrackingRecovery() + kotlinx.coroutines.delay(100) + } + } glassesScope.launch { while (true) { if (SessionState.running && SessionState.mode == SessionService.MODE_STEAM && @@ -564,6 +585,13 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { isFocusableInTouchMode = true defaultFocusHighlightEnabled = false setContent { + androidx.compose.runtime.SideEffect { + com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, + (drawerOpen || achievementsOpen || pcKeyboardOpen) && !pipUi && steamVrStatus != SteamVr.Status.RUNNING) + } + androidx.compose.runtime.DisposableEffect(Unit) { + onDispose { com.droiddeck.launcher.glasses.GlassesMenuMirror.setSessionMenuVisible(this@SessionActivity, false) } + } androidx.compose.runtime.LaunchedEffect(drawerOpen, pcKeyboardOpen, achievementsOpen, pipUi) { updatePointerCapture() } androidx.compose.runtime.LaunchedEffect(picturePosition, SessionState.running, pipUi, cardboard.enabled) { applyGameAlignment() } DroidDeckTheme { @@ -581,9 +609,20 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { cursorImage, cursorHotX, cursorHotY, cursorImageScale) if (hud.text.isNotEmpty()) HudText(hud.text) if (glassesOutputActive && !loading.visible) com.droiddeck.launcher.ui.GlassesPlayingHint(glasses.model) + if (trackingRecovery != null && !drawerOpen && !pcKeyboardOpen && !loading.visible) { + androidx.compose.ui.viewinterop.AndroidView( + factory = { com.droiddeck.launcher.ui.TrackingRecoveryView(it) }, + modifier = Modifier.fillMaxSize(), + update = { it.update(trackingRecovery, !glassesOutputActive && glasses.usable && glasses.sbs) }, + ) + } if (GlassesRendering.usesGlasses(glasses, glassesOutputActive, steamVrStatus == SteamVr.Status.RUNNING) && headTracking && !drawerOpen && !pcKeyboardOpen && !loading.visible) com.droiddeck.launcher.ui.GlassesRecenterButton( - controllerSettings?.tint ?: android.graphics.Color.rgb(90, 160, 255), controllerSettings?.opacity ?: 100) { headTracker?.recenter() } + controllerSettings?.tint ?: android.graphics.Color.rgb(90, 160, 255), controllerSettings?.opacity ?: 100, + onRecenterJoyCons = if (steamVrStatus == SteamVr.Status.RUNNING && + glasses.usesSpatialControllers(glassesSettings) && glassesSettings.joyConTracking) + joyConVr?.let { { it.recenter() } } else null, + ) { headTracker?.recenter() } if (glasses.present && !drawerOpen && !pcKeyboardOpen && !loading.visible) com.droiddeck.launcher.ui.GlassesCornerButton(glassesSlot, controllerSettings?.tint ?: android.graphics.Color.rgb(90, 160, 255), controllerSettings?.opacity ?: 100) { drawerPage = com.droiddeck.launcher.ui.SessionDrawerPage.GLASSES @@ -621,10 +660,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { steamVrSwitchedPicture, glassesVr, steamVrRequested) || (drawerOpen && drawerPage == SessionDrawerPage.VR) LaunchedEffect(pollSteamVr) { while (pollSteamVr) { + val request = steamVrRequestGeneration + val session = SessionState.sessionId val now = kotlinx.coroutines.withContext(kotlinx.coroutines.Dispatchers.IO) { SteamVr.status(this@SessionActivity) } - onSteamVrStatus(now) + if (request == steamVrRequestGeneration && session == SessionState.sessionId) onSteamVrStatus(now) kotlinx.coroutines.delay(3000) } } @@ -661,7 +702,10 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { onCardboardRecenter = { headTracker?.recenter() }, glassesPresent = glasses.present, glassesOutput = glassesOutputActive, - onGlassesRecenter = { headTracker?.recenter() }, + onGlassesRecenter = { + headTracker?.recenter() + com.droiddeck.launcher.glasses.GlassesMenuMirror.recenter() + }, steamVr = steamVrStatus, immersiveSteamVr = com.droiddeck.launcher.session.QuestExperimental.isSupported(), onSteamVr = { action -> steamVrAction(action) }, @@ -1426,6 +1470,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { activeCardboard = effectiveCardboard(SessionPrefs.cardboard(this)) pushCardboard(activeCardboard) WaylandCompositor.nativeSetCardboardPoseFile(File(filesDir, ".wayland-rt/droiddeck-headpose").path) + com.droiddeck.launcher.glasses.SpatialTracking.attachPublisher(File(filesDir, ".wayland-rt/droiddeck-spatialpose").path) if (!SessionState.running) { val waylandLog = File(SessionPaths.beginOrCurrent(this), "wayland.log") WaylandCompositor.setSessionLogFile(waylandLog) @@ -1646,6 +1691,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun onSessionEnded(status: Int) { ended = true + ++steamVrRequestGeneration if (isInPictureInPictureMode) { runOnUiThread { finish() } return @@ -2677,19 +2723,27 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { startActivity(android.content.Intent(this, QuestXrActivity::class.java)) return } + val request = ++steamVrRequestGeneration + val session = SessionState.sessionId + fun currentRequest() = request == steamVrRequestGeneration && session == SessionState.sessionId && !isDestroyed && !ended if (action == "start") { SessionState.steamVr = true steamVrAutoTried = true } - if (action == "stop") SessionState.steamVr = false + if (action == "stop") { + SessionState.steamVr = false + Glasses.cancelSteamVrStart() + } if (glasses.present) { // Optional stereo starts only after RUNNING is observed. READY can // arrive repeatedly while the launch worker is still starting VR. if (action == "install") steamVrStatus = SteamVr.Status.INSTALLING - steamVrWorker.execute { + runSteamVrAction(action, ::currentRequest) { val ok = SteamVr.run(this, action) val now = SteamVr.status(this) uiHandler.post { + if (!currentRequest()) return@post + if (!ok && now != SteamVr.Status.RUNNING) Glasses.cancelSteamVrStart() onSteamVrStatus(now) if (!ok) Toast.makeText(this, getString(R.string.cardboard_steamvr_failed), Toast.LENGTH_LONG).show() } @@ -2702,10 +2756,12 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } if (action == "stop") restoreSteamVrPicture() if (action == "install") steamVrStatus = SteamVr.Status.INSTALLING - steamVrWorker.execute { + runSteamVrAction(action, ::currentRequest) { val ok = SteamVr.run(this, action) val now = SteamVr.status(this) uiHandler.post { + if (!currentRequest()) return@post + if (!ok && now != SteamVr.Status.RUNNING) Glasses.cancelSteamVrStart() if (!ok && action == "start" && now != SteamVr.Status.RUNNING) restoreSteamVrPicture() onSteamVrStatus(now) if (!ok) Toast.makeText(this, getString(R.string.cardboard_steamvr_failed), Toast.LENGTH_LONG).show() @@ -2713,6 +2769,20 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } } + private fun runSteamVrAction(action: String, currentRequest: () -> Boolean, run: () -> Unit) { + if (action != "start") { + steamVrWorker.execute(run) + return + } + Glasses.prepareSteamVrStart { + uiHandler.post { + if (SessionState.steamVr && currentRequest()) steamVrWorker.execute { + if (SessionState.steamVr && currentRequest()) run() + } + } + } + } + private fun switchPictureForSteamVr() { if (cardboard.source != Cardboard.SOURCE_SBS) { SessionPrefs.setCardboardSourceBeforeSteamVr(this, cardboard.source) @@ -2723,10 +2793,21 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { steamVrSwitchedPicture = SessionPrefs.cardboardSourceBeforeSteamVr(this) >= 0 } + private fun usesSpatialControllers() = + GlassesRendering.usesGlasses(glasses, glassesScreen != null, steamVrStatus == SteamVr.Status.RUNNING) && + glasses.usesSpatialControllers(glassesSettings) + + private fun updateJoyConTracking() { + joyConVr?.setActive(steamVrStatus == SteamVr.Status.RUNNING && + (ControllerPrefs.joyConVr(this) || + (usesSpatialControllers() && glassesSettings.joyConTracking))) + } + private fun updateHandCamera() { val joyCons = joyConVr?.holding == true val bare = !joyCons && !controllerConnected() val want = started && steamVrStatus == SteamVr.Status.RUNNING && (joyCons || bare) && + !usesSpatialControllers() && com.droiddeck.launcher.handtracking.HandTracking.wanted(this) handCamera?.bareHands = bare if (want == (handCamera != null)) return @@ -2748,12 +2829,14 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { } private fun onSteamVrStatus(now: SteamVr.Status) { + if (ended || isDestroyed) return val was = steamVrStatus steamVrStatus = now - joyConVr?.setActive(now == SteamVr.Status.RUNNING && ControllerPrefs.joyConVr(this)) + updateJoyConTracking() updateHandCamera() autoStartSteamVr(now) if ((was == SteamVr.Status.RUNNING) != (now == SteamVr.Status.RUNNING)) applyCardboard(cardboard) + if (now != SteamVr.Status.UNAVAILABLE) Glasses.setVrActive(now == SteamVr.Status.RUNNING) if (glasses.present) onGlassesSteamVr(now) if (GlassesRendering.usesGlasses(glasses, glassesScreen != null, now == SteamVr.Status.RUNNING)) { return @@ -2809,15 +2892,17 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun updateHeadTracker() { val onGlasses = GlassesRendering.usesGlasses(glasses, glassesScreen != null, steamVrStatus == SteamVr.Status.RUNNING) + SpatialTracking.setOutputUsesGlasses(onGlasses && !ended) val c = activeCardboard + val centerView = onGlasses && c.source == Cardboard.SOURCE_SCREEN val want = !ended && (resumed || (glassesScreen != null && started)) && c.enabled && c.headTracking val current = headTracker - if (current != null && (!want || current.usesGlasses != onGlasses)) { + if (current != null && (!want || current.usesGlasses != onGlasses || current.centerView != centerView)) { current.stop() headTracker = null } if (want) { - val t = headTracker ?: HeadTracker(this, glasses = onGlasses) { + val t = headTracker ?: HeadTracker(this, glasses = onGlasses, centerView = centerView) { @Suppress("DEPRECATION") (if (Build.VERSION.SDK_INT >= 30) display else windowManager.defaultDisplay)?.rotation ?: android.view.Surface.ROTATION_0 }.also { headTracker = it } @@ -2826,6 +2911,18 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { headTracking = headTracker != null } + private fun updateTrackingRecovery() { + val onGlasses = GlassesRendering.usesGlasses(glasses, glassesScreen != null, + steamVrStatus == SteamVr.Status.RUNNING) + val spatialView = onGlasses && SpatialTracking.selected && glassesSettings.positionalTracking && + (SessionState.steamVr || steamVrStatus == SteamVr.Status.RUNNING || + (glassesOutputActive && glassesSettings.headTracking && glassesSettings.picture3d == com.droiddeck.launcher.glasses.GlassesSettings.PICTURE_SCREEN)) + val active = started && !ended && SessionState.running && !loading.visible && !pipUi && spatialView + if (active) SpatialTracking.refreshStatus() + trackingRecovery = TrackingRecovery.forSession(active, glasses.canControl, SpatialTracking.status.value) + glassesScreen?.trackingRecovery?.update(trackingRecovery, glasses.sbs) + } + private fun outputHolder(): SurfaceHolder = glassesScreen?.holder ?: surfaceView.holder private fun onOutputAttached(holder: SurfaceHolder) { @@ -2864,7 +2961,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { private fun onGlassesChanged() { val g = glasses val s = glassesSettings - val key = listOf(g.present, g.usable, g.displayId, g.sbs, g.sbs90, g.switching3d, g.canControl, g.width, g.height, g.hz, s) + val key = listOf(g.present, g.usable, g.displayId, g.sbs, g.sbs90, g.supports30Hz, g.switching3d, g.canControl, g.width, g.height, g.hz, g.resolutions, g.vrActive, s) if (key == glassesKey) return glassesKey = key updateGlassesScreen() @@ -2898,7 +2995,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { val target = if (want) Glasses.glassesDisplay()?.takeIf { it.isValid } else null val current = glassesScreen if (current != null && current.display.displayId == target?.displayId) { - current.prefer(Glasses.outputHz()) + current.prefer(Glasses.outputHz(), Glasses.outputResolution()) applyOutputPacing() return } @@ -2907,7 +3004,7 @@ class SessionActivity : ComponentActivity(), SurfaceHolder.Callback { runCatching { current.dismiss() } } if (target != null) { - val screen = GlassesScreen(this, target, Glasses.outputHz(), this) + val screen = GlassesScreen(this, target, Glasses.outputHz(), this, Glasses.outputResolution()) // show() can create the surface synchronously. Select its holder // first, otherwise surfaceCreated() rejects the glasses callback. glassesScreen = screen diff --git a/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt b/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt index 982deedaf3..a4322909ad 100644 --- a/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt +++ b/app/src/main/java/com/droiddeck/launcher/agent/AgentBridgeProvider.kt @@ -108,15 +108,19 @@ class AgentBridgeProvider : ContentProvider() { val value = request.optString("value") fun on() = value == "1" || value.equals("true", true) || value.equals("on", true) val number = value.toIntOrNull() - val numeric = setOf("refreshHz", "sbsHz", "brightness", "volume", "picture3d", "screenWidthDm", "screenDistanceDm", "vrFovDeg", "sbsSupport") + val numeric = setOf("refreshHz", "sbsHz", "brightness", "volume", "picture3d", "screenWidthDm", "screenDistanceDm", "vrFovDeg", "sbsSupport", "eyeHeightCm") if (key in numeric && number == null) return error("INVALID_VALUE", "'$key' takes a number") when (key) { "refreshHz" -> g.setRefreshHz(number!!) "sbsHz" -> g.setSbsHz(number!!) + "resolution2d" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.TWO_D, value) + "resolution3d" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.THREE_D, value) + "resolutionVr" -> g.setResolution(com.droiddeck.launcher.glasses.GlassesDisplayProfile.VR, value) "brightness" -> g.setBrightness(number!!) "volume" -> g.setVolume(number!!) "sunblock" -> g.setSunblock(on()) "3d" -> g.set3d(on()) + "3dof" -> g.set3dof(on()) "gameOnGlasses" -> g.setGameOnGlasses(on()) "headTracking" -> g.setHeadTracking(on()) "auto3d" -> g.setAuto3d(on()) @@ -125,6 +129,10 @@ class AgentBridgeProvider : ContentProvider() { "screenDistanceDm" -> g.setScreenDistanceDm(number!!) "vrFovDeg" -> g.setVrFovDeg(number!!) "sbsSupport" -> g.setSbsSupport(number!!) + "positionalTracking" -> g.setPositionalTracking(on()) + "handControllers" -> g.setHandControllers(on()) + "joyConTracking" -> g.setJoyConTracking(on()) + "eyeHeightCm" -> g.setEyeHeight(number!!) else -> return error("INVALID_KEY", "Unknown glasses setting '$key'") } } @@ -136,6 +144,34 @@ class AgentBridgeProvider : ContentProvider() { "calibrate" -> g.startCalibration() "cancel-calibration" -> g.cancelCalibration() "reset-calibration" -> g.resetCalibration() + "spatial-diagnostics" -> com.droiddeck.launcher.glasses.SpatialTracking.diagnostics(request.optBoolean("enabled",true)) + "spatial-recenter" -> com.droiddeck.launcher.glasses.SpatialTracking.recenter(request.optBoolean("screen",false)) + "spatial-floor" -> g.setSpatialFloor() + "spatial-restart" -> g.restartSpatialTracking() + "spatial-hand-options" -> { + AgentAccess.requireCommands(context) + if(request.has("lite")) com.droiddeck.launcher.glasses.SpatialTracking.setHandModel(request.getBoolean("lite")) + if(request.has("parallel")) com.droiddeck.launcher.glasses.SpatialTracking.setHandCpuParallel(request.getBoolean("parallel")) + if(request.has("halfRate")) com.droiddeck.launcher.glasses.SpatialTracking.setHandHalfRate(request.getBoolean("halfRate")) + if(request.has("adaptive")) com.droiddeck.launcher.glasses.SpatialTracking.setHandAdaptiveInput(request.getBoolean("adaptive")) + if(request.has("scheduled")) com.droiddeck.launcher.glasses.SpatialTracking.setHandScheduledTracking(request.getBoolean("scheduled")) + } + "spatial-hand-benchmark" -> { + AgentAccess.requireCommands(context) + com.droiddeck.launcher.glasses.SpatialTracking.benchmarkSavedCapture(request.getString("capture")) + } + "spatial-hand-capture" -> { + AgentAccess.requireCommands(context) + com.droiddeck.launcher.glasses.SpatialTracking.captureDiagnostic() + } + "spatial-rgb-capture", "spatial-rgb-status" -> { + AgentAccess.requireCommands(context) + return (if (request.getString("op") == "spatial-rgb-capture") + com.droiddeck.launcher.glasses.LumaRgbDiagnostic.capture(context!!,request.optString("transport","sdk"), + request.optInt("width",640),request.optInt("height",480),request.optInt("fps",30), + request.optInt("durationMs",5000)) + else com.droiddeck.launcher.glasses.LumaRgbDiagnostic.status(context!!)).put("ok", true) + } "query" -> { g.query(); Thread.sleep(600) } "mode" -> { val mode = hex(request.optString("mode"), 0xFF) ?: return error("INVALID_VALUE", "mode must be one hex byte, e.g. 0x31") diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheck.kt b/app/src/main/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheck.kt new file mode 100644 index 0000000000..37efa034c0 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheck.kt @@ -0,0 +1,24 @@ +package com.droiddeck.launcher.glasses + +import android.content.Context +import com.droiddeck.launcher.R +import kotlin.math.abs + +internal data class CalibrationDistanceResult(val accepted: Boolean, val message: String) + +internal object CalibrationDistanceCheck { + fun evaluate(context: Context, expected: Float, corners: Int, points: List?): CalibrationDistanceResult { + require(expected.isFinite() && expected in 0.15f..1.5f) + if (corners != 24) return CalibrationDistanceResult(false, + context.getString(R.string.spatial_distance_corners, corners)) + if (points?.size != 24 || points.any { !it.finite() }) return CalibrationDistanceResult(false, + context.getString(R.string.spatial_distance_depth)) + val measured=(points.reduce { a,b -> a+b }*(1f/points.size)).length() + if (!measured.isFinite()) return CalibrationDistanceResult(false,context.getString(R.string.spatial_distance_invalid)) + val accepted=abs(measured-expected)<0.05f + return CalibrationDistanceResult(accepted, + context.getString(R.string.spatial_distance_result, + SpatialMeasurements.validation(measured), SpatialMeasurements.validation(expected), + context.getString(if (accepted) R.string.spatial_distance_passed else R.string.spatial_distance_retry))) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/CalibrationObservationData.kt b/app/src/main/java/com/droiddeck/launcher/glasses/CalibrationObservationData.kt new file mode 100644 index 0000000000..4df64156cd --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/CalibrationObservationData.kt @@ -0,0 +1,27 @@ +package com.droiddeck.launcher.glasses + +import org.json.JSONObject + +internal data class CalibrationObservationData( + val objects: List, val left: List, val right: List, val head: SpatialPose, +) { + companion object { + fun parse(view: JSONObject): CalibrationObservationData { + fun points(name: String, dimensions: Int): List { + val rows=view.getJSONArray(name) + require(rows.length() in 12..24) { "Invalid saved board corner count" } + return (0 until rows.length()).map { row -> + val values=rows.getJSONArray(row) + require(values.length()==dimensions) + DoubleArray(dimensions) { values.getDouble(it).also { value -> require(value.isFinite()) } } + } + } + val objects=points("objects",3); val left=points("left",2); val right=points("right",2) + require(objects.size==left.size && objects.size==right.size) + val pose=view.getJSONArray("head") + require(pose.length()==7) + val head=SpatialPose.fromSdk(FloatArray(7) { pose.getDouble(it).toFloat() }) ?: error("Invalid saved head pose") + return CalibrationObservationData(objects,left,right,head) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt b/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt index 4307e5e3a6..89d5fcbde0 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt @@ -51,10 +51,18 @@ data class GlassesState( val sbsSupport: Int = SBS_UNKNOWN, val sbs90: Boolean = false, val experimental: Boolean = false, + val supportsScreen3dof: Boolean = false, + val supports30Hz: Boolean = false, + val supportsSpatial: Boolean = false, + val resolutions: List = emptyList(), + val vrActive: Boolean = false, ) { val hasDisplay: Boolean get() = displayId != Display.INVALID_DISPLAY val usable: Boolean get() = hasDisplay && !noSignal val canControl: Boolean get() = connected && controllable + val spatialConnected: Boolean get() = canControl && supportsSpatial + fun usesSpatialControllers(settings: GlassesSettings) = spatialConnected && settings.positionalTracking && + (settings.handControllers || settings.joyConTracking) val can3d: Boolean get() = canControl && !noSignal && sbsSupport != SBS_FAILS val verticalFovDeg: Float get() { val half = Math.toRadians(diagonalFovDeg / 2.0) @@ -74,6 +82,9 @@ data class GlassesState( data class GlassesSettings( val refreshHz: Int = 120, val sbsHz: Int = 60, + val resolution2d: String = "", + val resolution3d: String = "", + val resolutionVr: String = "", val sunblock: Boolean? = null, val gameOnGlasses: Boolean = true, val headTracking: Boolean = true, @@ -82,7 +93,14 @@ data class GlassesSettings( val screenWidthDm: Int = 20, val screenDistanceDm: Int = 30, val vrFovDeg: Int = VR_FOV_DEFAULT, + val positionalTracking: Boolean = false, + val handControllers: Boolean = false, + val joyConTracking: Boolean = false, + val steadyHandAim: Boolean = false, + val eyeHeightCm: Int = 160, ) { + val screen3dof: Boolean get() = picture3d == PICTURE_SCREEN && headTracking + companion object { const val VR_FOV_MIN = 24 const val VR_FOV_MAX = 90 @@ -129,10 +147,13 @@ object Glasses { private var lastModeSentAt = 0L private val modeState = GlassesModeState(SBS_CONFIRM_MS) private val confirmMode = Runnable { refresh() } + private val steamVrSpatialGate = SteamVrSpatialGate() + private val resumeSteamVrSpatial = Runnable { updateSpatialMode() } private var glassesMode = 0 private var autoModeSent = false @Volatile private var sink: PoseSink? = null + private val poseObservers = java.util.concurrent.CopyOnWriteArraySet() @Volatile private var probe: ((ByteArray?, FloatArray?) -> Unit)? = null @Volatile private var latest: FloatArray? = null @Volatile private var imuPackets = 0L @@ -142,6 +163,7 @@ object Glasses { fun init(context: Context) { if (::handler.isInitialized) return app = context.applicationContext + SpatialTracking.initialize(app) usb = app.getSystemService(Context.USB_SERVICE) as UsbManager displays = app.getSystemService(Context.DISPLAY_SERVICE) as DisplayManager _settings.value = load() @@ -200,13 +222,84 @@ object Glasses { } fun setRefreshHz(hz: Int) = post { - update { it.copy(refreshHz = hz.coerceIn(60, 120)) } + if (hz == 30 && (_state.value.sbs || !GlassesRendering.native30HzAvailable(_settings.value, _state.value))) return@post + update { it.copy(refreshHz = if (hz == 30) 30 else hz.coerceIn(60, 120)) } if (!_state.value.sbs) applyMode(force = true) } fun setSbsHz(hz: Int) = post { - update { it.copy(sbsHz = if (hz >= 90) 90 else 60) } - if (_state.value.sbs && _state.value.can3d) sendMode(true) + if (hz == 30 && (!_state.value.sbs || !GlassesRendering.native30HzAvailable(_settings.value, _state.value))) return@post + update { it.copy(sbsHz = when { hz == 30 -> 30; hz >= 90 -> 90; else -> 60 }) } + if (hz != 30 && _state.value.sbs && _state.value.can3d) sendMode(true) + } + + fun setResolution(profile: GlassesDisplayProfile, value: String) = post { + val s = _state.value + val choice = if (value == "auto") "" else value + if (choice.isNotEmpty() && s.resolutions.none { it.key == choice }) return@post + if (GlassesDisplayModes.choice(_settings.value, profile) == choice) return@post + update { when (profile) { + GlassesDisplayProfile.TWO_D -> it.copy(resolution2d = choice) + GlassesDisplayProfile.THREE_D -> it.copy(resolution3d = choice) + GlassesDisplayProfile.VR -> it.copy(resolutionVr = choice) + } } + val active = GlassesDisplayModes.profile(s.sbs, s.vrActive) + val inheritedByVr = s.vrActive && _settings.value.resolutionVr.isEmpty() && + profile == GlassesDisplayModes.profile(s.sbs, false) + if ((profile == active || inheritedByVr) && s.canControl && !s.switching3d && + model?.resolutions?.isNotEmpty() == true) sendMode(s.sbs) + } + + fun prepareSteamVrStart(onPrepared: () -> Unit = {}) { + if (!::handler.isInitialized) { + steamVrSpatialGate.prepare() + onPrepared() + return + } + post { + if (steamVrSpatialGate.prepare()) { + handler.removeCallbacks(resumeSteamVrSpatial) + updateSpatialMode() + } + onPrepared() + } + } + + fun cancelSteamVrStart() { + if (!::handler.isInitialized) { + steamVrSpatialGate.cancel() + return + } + post { + steamVrSpatialGate.cancel() + handler.removeCallbacks(resumeSteamVrSpatial) + updateSpatialMode() + } + } + + fun setVrActive(on: Boolean) = post { + val s = _state.value + val trackingChanged = steamVrSpatialGate.setRunning(on, SystemClock.uptimeMillis()) + if (trackingChanged) { + handler.removeCallbacks(resumeSteamVrSpatial) + steamVrSpatialGate.deadline?.let { + Log.i(TAG, "SteamVR RUNNING; spatial resume scheduled at uptime ${it}ms") + handler.postAtTime(resumeSteamVrSpatial, it) + } + } + if (s.vrActive == on) { + if (trackingChanged) updateSpatialMode() + return@post + } + val previous = GlassesDisplayModes.selected(_settings.value, s) + publish { it.copy(vrActive = on) } + val restore2d = !on && modeState.stopVr() + val stereo = (s.sbs || modeState.pendingStereo) && !restore2d + val selected = GlassesDisplayModes.selected(_settings.value, _state.value, stereo) + if (s.canControl && s.usable && (restore2d || + (previous != selected && model?.resolutions?.isNotEmpty() == true)) && + !(on && _settings.value.auto3d && !s.sbs)) sendMode(stereo) + updateSpatialMode() } fun set3d(on: Boolean) = post { @@ -255,7 +348,59 @@ object Glasses { markSbsFailed(linkDevice?.productId, s == GlassesState.SBS_FAILS) rememberSbs(s) } - fun setGameOnGlasses(on: Boolean) = post { update { it.copy(gameOnGlasses = on) } } + fun setGameOnGlasses(on: Boolean) = post { + val s = _state.value + if (!on && s.canControl && (s.sbs || modeState.pendingStereo)) { + modeState.manual() + sendMode(false) + } + update { + it.copy( + gameOnGlasses = on, + picture3d = if (!on && it.picture3d == GlassesSettings.PICTURE_SCREEN) + GlassesSettings.PICTURE_AUTO else it.picture3d, + ) + } + } + fun set3dof(on: Boolean) = post { + if (!_state.value.supportsScreen3dof) return@post + update { + it.copy( + gameOnGlasses = on || it.gameOnGlasses, + headTracking = on || it.headTracking, + picture3d = if (on) GlassesSettings.PICTURE_SCREEN + else if (it.picture3d == GlassesSettings.PICTURE_SCREEN) GlassesSettings.PICTURE_AUTO else it.picture3d, + ) + } + } + fun setPositionalTracking(on: Boolean) = post { + if (!_state.value.spatialConnected || _settings.value.positionalTracking == on) return@post + update { it.copy(positionalTracking = on, handControllers = it.handControllers && on, + joyConTracking = it.joyConTracking && on) } + if (!on) SpatialTracking.setControllers(false, false) + closeLink() + refresh() + } + fun setHandControllers(on: Boolean) = post { + val wanted = on && _settings.value.positionalTracking && _state.value.spatialConnected + update { it.copy(handControllers = wanted, joyConTracking = it.joyConTracking && !wanted) } + SpatialTracking.setControllers(wanted, _settings.value.joyConTracking) + } + fun setSteadyHandAim(on: Boolean) = post { + update { it.copy(steadyHandAim = on) } + SpatialTracking.setSteadyHandAim(on) + } + fun setJoyConTracking(on: Boolean) = post { + val wanted = on && _settings.value.positionalTracking && _state.value.spatialConnected + update { it.copy(joyConTracking = wanted, handControllers = it.handControllers && !wanted) } + SpatialTracking.setControllers(_settings.value.handControllers, wanted) + } + fun setEyeHeight(cm: Int) = post { update { it.copy(eyeHeightCm = cm.coerceIn(50, 250)) } } + fun setSpatialFloor() = SpatialTracking.setFloor(_settings.value.eyeHeightCm / 100f) + fun restartSpatialTracking() = post { + if (_state.value.spatialConnected && _settings.value.positionalTracking) { closeLink(); refresh() } + } + fun setHeadTracking(on: Boolean) = post { update { it.copy(headTracking = on) } } fun setAuto3d(on: Boolean) = post { update { it.copy(auto3d = on) } } fun setPicture3d(picture: Int) = post { update { it.copy(picture3d = picture.coerceIn(0, 2)) } } @@ -264,6 +409,7 @@ object Glasses { fun setVrFovDeg(deg: Int) = post { update { it.copy(vrFovDeg = deg.coerceIn(GlassesSettings.VR_FOV_MIN, GlassesSettings.VR_FOV_MAX)) } } fun outputHz(): Int = GlassesRendering.outputHz(_settings.value, _state.value) + fun outputResolution(): GlassesResolution? = GlassesDisplayModes.selected(_settings.value, _state.value) fun glassesDisplay(): Display? = _state.value.displayId.takeIf { it != Display.INVALID_DISPLAY }?.let { displays.getDisplay(it) } @@ -277,6 +423,16 @@ object Glasses { post { updateImu() } } + internal fun addPoseObserver(observer: PoseSink) { + poseObservers.add(observer) + post { updateImu() } + } + + internal fun removePoseObserver(observer: PoseSink) { + poseObservers.remove(observer) + post { updateImu() } + } + fun simulate(seconds: Int, holdYaw: Double? = null, holdPitch: Double? = null): Boolean { val hold = holdYaw != null || holdPitch != null val t = Thread({ @@ -312,6 +468,15 @@ object Glasses { .put("permission", s.permission.name).put("connected", s.connected) .put("controlError", s.controlError ?: JSONObject.NULL) .put("experimental", s.experimental) + .put("supportsScreen3dof", s.supportsScreen3dof) + .put("supportsSpatial", s.supportsSpatial) + .put("firmware", (link as? VitureSdkLink)?.firmware ?: JSONObject.NULL) + .put("spatialSdk", (link as? VitureSdkLink)?.spatialDiagnostics()?.let { + JSONObject().put("status",it[0]).put("callbackAgeMs",it[1]).put("cameraPoseDeltaMs",it[2]) + } ?: JSONObject.NULL) + .put("spatial", SpatialTracking.diagnosticStatus()) + .put("supports30Hz", s.supports30Hz).put("vrActive", s.vrActive) + .put("resolutions", JSONArray(s.resolutions.map { it.key })) .put("display", if (s.hasDisplay) JSONObject().put("id", s.displayId).put("width", s.width).put("height", s.height).put("hz", s.hz.toDouble()) else JSONObject.NULL) .put("sbs", s.sbs).put("deviceMode", glassesMode).put("switching3d", s.switching3d) .put("brightness", s.brightness).put("volume", s.volume) @@ -325,6 +490,11 @@ object Glasses { .put("fovDeg", s.diagonalFovDeg.toDouble()).put("noSignal", s.noSignal).put("sbsSupport", s.sbsSupport) .put("settings", JSONObject().put("refreshHz", g.refreshHz).put("sbsHz", g.sbsHz).put("sunblock", g.sunblock ?: JSONObject.NULL) .put("gameOnGlasses", g.gameOnGlasses).put("headTracking", g.headTracking).put("auto3d", g.auto3d) + .put("screen3dof", g.screen3dof) + .put("resolution2d", g.resolution2d).put("resolution3d", g.resolution3d).put("resolutionVr", g.resolutionVr) + .put("positionalTracking", g.positionalTracking).put("handControllers", g.handControllers) + .put("joyConTracking", g.joyConTracking).put("eyeHeightCm", g.eyeHeightCm) + .put("steadyHandAim", g.steadyHandAim) .put("picture3d", g.picture3d).put("screenWidthDm", g.screenWidthDm).put("screenDistanceDm", g.screenDistanceDm) .put("vrFovDeg", g.vrFovDeg)) } @@ -450,6 +620,14 @@ object Glasses { noSignal = noSignal, sbs90 = m?.sbs90 == true, experimental = m === XrealModel, + supportsScreen3dof = link?.hasImu == true, + supports30Hz = display?.let(::supports30Hz) == true, + supportsSpatial = (link as? VitureSdkLink)?.isCarina == true, + resolutions = m?.resolutions?.takeIf { modes -> modes.isNotEmpty() } + ?: display?.supportedModes.orEmpty().filter { mode -> + mode.physicalWidth >= 1280 && (mode.physicalWidth >= 3000) == sbsByDisplay + }.map { mode -> GlassesResolution(mode.physicalWidth / (if (sbsByDisplay) 2 else 1), mode.physicalHeight) } + .distinct().sortedWith(compareBy({ size -> size.height }, { size -> size.width })), ) } if (link != null) applyMode(force = false) @@ -458,6 +636,14 @@ object Glasses { internal fun isGlassesVendor(vid: Int) = vid == VitureProtocol.VENDOR_ID || RayNeoModel.isVendor(vid) || vid == XrealModel.VENDOR_ID + internal fun supports30Hz(display: Display): Boolean { + val current = display.mode + return display.supportedModes.any { + it.physicalWidth == current.physicalWidth && it.physicalHeight == current.physicalHeight && + abs(it.refreshRate - 30f) < 0.5f + } + } + private fun canOpenModel(m: GlassesModel): Boolean = m.controllable && (m !is VitureProtocol.Model || !m.needsSdk || VitureSdk.available) @@ -511,14 +697,29 @@ object Glasses { runCatching { usb.requestPermission(device, pi) }.onFailure { Log.w(TAG, "requestPermission", it) } } + private fun updateSpatialMode() { + val current = link as? VitureSdkLink ?: return + if (!current.ready || !current.isCarina || current.spatialEnabled == + steamVrSpatialGate.spatialEnabled(_settings.value.positionalTracking, SystemClock.uptimeMillis())) return + val device = linkDevice + closeLink() + refresh() + val resumed = link as? VitureSdkLink + if (!current.spatialEnabled && resumed?.isCarina == true && resumed.spatialEnabled && + device != null && linkDevice?.deviceName == device.deviceName) SpatialTracking.recenter(false) + } + private fun openLink(device: UsbDevice) { val generation = ++linkGeneration + val spatial = steamVrSpatialGate.spatialEnabled(_settings.value.positionalTracking, SystemClock.uptimeMillis()) calibrationKey = calibrationStore.key(device.vendorId, device.productId, runCatching { device.serialNumber }.getOrNull(), model?.name.orEmpty()) val l = if (device.vendorId == VitureProtocol.VENDOR_ID) { if ((model as? VitureProtocol.Model)?.needsSdk == true) { - VitureSdkLink.open(usb, device, File(app.cacheDir, "viture"), sdkListener(generation), - (model as? VitureProtocol.Model)?.family) + // Android can evict cacheDir while the SDK is running. + Log.i(TAG, "opening VITURE SDK pid=0x%04X spatial=%s".format(device.productId, spatial)) + VitureSdkLink.open(usb, device, File(app.noBackupFilesDir, "viture"), sdkListener(generation), + (model as? VitureProtocol.Model)?.family, spatial) } else VitureLink.open(usb, device, linkListener(generation)) } else if (model === XrealModel) { XrealLink.open(app, xrealListener(generation)) @@ -536,6 +737,12 @@ object Glasses { return } link = opened + if (opened is VitureSdkLink && opened.isCarina) SpatialTracking.connect(opened.sdkToken, generation, + opened.spatialIdentity ?: runCatching { device.serialNumber }.getOrNull()?.takeIf { it.isNotBlank() } + ?.let { "${device.vendorId}:${device.productId}:$it" }, + spatial, _settings.value.eyeHeightCm / 100f, _settings.value.handControllers, + _settings.value.joyConTracking, _settings.value.steadyHandAim) + else SpatialTracking.useLegacyTracking() _calibration.value = GlassesCalibrationState(supported = opened is RayNeoLink, saved = opened is RayNeoLink && calibrationKey?.let(calibrationStore::load) != null) linkDevice = device @@ -584,6 +791,9 @@ object Glasses { } private fun sdkListener(generation: Long) = object : VitureSdkLink.Listener { + override fun onSpatial(pose: FloatArray, timeNs: Long, valid: Boolean) { + if (generation == linkGeneration) SpatialTracking.accept(pose, timeNs, generation, valid) + } override fun onValue(msgId: Int, value: Int) = post { if (generation != linkGeneration) return@post when (msgId) { @@ -652,13 +862,14 @@ object Glasses { private fun closeLink() { val l = link ?: return linkGeneration++ + SpatialTracking.disconnect() link = null linkDevice = null calibrationKey = null _calibration.value = GlassesCalibrationState(phase = if (_calibration.value.running) CalibrationPhase.FAILED else CalibrationPhase.IDLE) glassesMode = 0 l.close() - publish { it.copy(connected = false, tracking = false) } + publish { it.copy(connected = false, tracking = false, supportsScreen3dof = false, supportsSpatial = false) } Log.i(TAG, "link closed") } @@ -688,10 +899,14 @@ object Glasses { } if (!s.usable || s.sbs || modeState.pendingStereo) return val hz = _settings.value.refreshHz - if (glassesMode == m.mode(hz, false)) return + // Native 30 Hz is selected by the Android presentation, without a vendor mode command. + if (hz == 30 && GlassesRendering.native30HzAvailable(_settings.value, s)) return + if (glassesMode == m.mode(hz, false, outputResolution())) return if (!force) { if (autoModeSent || SystemClock.uptimeMillis() - lastModeSentAt < 8_000) return - if (glassesMode == 0 && abs(s.hz - hz) < 1.5f) return + val resolution = outputResolution() + if (glassesMode == 0 && abs(s.hz - hz) < 1.5f && + (resolution == null || (s.width == resolution.width && s.height == resolution.height))) return autoModeSent = true } sendMode(false) @@ -699,8 +914,10 @@ object Glasses { private fun sendMode(sbs: Boolean): Boolean { val m = model ?: return false + if (sbs && !_settings.value.gameOnGlasses) update { it.copy(gameOnGlasses = true) } val g = _settings.value - val mode = m.mode(if (sbs) g.sbsHz else g.refreshHz, sbs) + val resolution = GlassesDisplayModes.selected(g, _state.value, sbs) + val mode = m.mode(if (sbs) g.sbsHz else g.refreshHz, sbs, resolution) if (link?.send(VitureProtocol.MSG_DISPLAY, byteArrayOf(mode.toByte())) == true) { if (link is RayNeoLink) glassesMode = mode lastModeSentAt = SystemClock.uptimeMillis() @@ -728,7 +945,7 @@ object Glasses { private fun updateImu() { val l = link ?: return if (!l.ready) return - val want = (sink != null || probe != null || _calibration.value.running) && l.hasImu + val want = (sink != null || poseObservers.isNotEmpty() || probe != null || _calibration.value.running || SpatialTracking.enabled) && l.hasImu if (want == _state.value.tracking) return val accepted = l.send(VitureProtocol.MSG_IMU, byteArrayOf(if (want) 1 else 0)) if (want && !accepted) return @@ -769,6 +986,7 @@ object Glasses { private fun deliver(q: FloatArray, timeNs: Long) { latest = q sink?.onPose(q[0], q[1], q[2], q[3], timeNs) + poseObservers.forEach { it.onPose(q[0], q[1], q[2], q[3], timeNs) } } private fun onReport(frame: VitureProtocol.Frame) { @@ -832,8 +1050,16 @@ object Glasses { private fun load(): GlassesSettings { val p = app.getSharedPreferences(PREFS, Context.MODE_PRIVATE) return GlassesSettings( + positionalTracking = p.getBoolean("positionalTracking", false), + handControllers = p.getBoolean("handControllers", false), + joyConTracking = p.getBoolean("joyConTracking", false), + steadyHandAim = p.getBoolean("steadyHandAim", false), + eyeHeightCm = p.getInt("eyeHeightCm", 160).coerceIn(50, 250), refreshHz = p.getInt("refreshHz", 120), sbsHz = p.getInt("sbsHz", 60), + resolution2d = p.getString("resolution2d", "").orEmpty(), + resolution3d = p.getString("resolution3d", "").orEmpty(), + resolutionVr = p.getString("resolutionVr", "").orEmpty(), sunblock = if (p.contains("sunblock")) p.getBoolean("sunblock", false) else null, gameOnGlasses = p.getBoolean("gameOnGlasses", true), headTracking = p.getBoolean("headTracking", true), @@ -847,8 +1073,16 @@ object Glasses { private fun save(s: GlassesSettings) { app.getSharedPreferences(PREFS, Context.MODE_PRIVATE).edit().apply { + putBoolean("positionalTracking", s.positionalTracking) + putBoolean("handControllers", s.handControllers) + putBoolean("joyConTracking", s.joyConTracking) + putBoolean("steadyHandAim", s.steadyHandAim) + putInt("eyeHeightCm", s.eyeHeightCm) putInt("refreshHz", s.refreshHz) putInt("sbsHz", s.sbsHz) + putString("resolution2d", s.resolution2d) + putString("resolution3d", s.resolution3d) + putString("resolutionVr", s.resolutionVr) s.sunblock?.let { putBoolean("sunblock", it) } ?: remove("sunblock") putBoolean("gameOnGlasses", s.gameOnGlasses) putBoolean("headTracking", s.headTracking) diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesDisplayModes.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesDisplayModes.kt new file mode 100644 index 0000000000..7cb533b968 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesDisplayModes.kt @@ -0,0 +1,29 @@ +package com.droiddeck.launcher.glasses + +data class GlassesResolution(val width: Int, val height: Int) { + val key: String get() = "${width}x$height" +} + +enum class GlassesDisplayProfile { TWO_D, THREE_D, VR } + +internal object GlassesDisplayModes { + fun profile(stereo: Boolean, vr: Boolean): GlassesDisplayProfile = when { + vr -> GlassesDisplayProfile.VR + stereo -> GlassesDisplayProfile.THREE_D + else -> GlassesDisplayProfile.TWO_D + } + + fun choice(settings: GlassesSettings, profile: GlassesDisplayProfile): String = when (profile) { + GlassesDisplayProfile.TWO_D -> settings.resolution2d + GlassesDisplayProfile.THREE_D -> settings.resolution3d + GlassesDisplayProfile.VR -> settings.resolutionVr + } + + fun selected(settings: GlassesSettings, state: GlassesState, + stereo: Boolean = state.sbs, vr: Boolean = state.vrActive): GlassesResolution? { + val selected = choice(settings, profile(stereo, vr)).ifEmpty { + if (vr) choice(settings, profile(stereo, false)) else "" + } + return state.resolutions.firstOrNull { it.key == selected } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt index 708520c38c..0f6c288334 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesHardware.kt @@ -9,6 +9,8 @@ interface GlassesModel { val diagonalFovDeg: Float val sbs90: Boolean val hasSunblock: Boolean get() = true + val resolutions: List get() = emptyList() + fun mode(hz: Int, sbs: Boolean, resolution: GlassesResolution?): Int = mode(hz, sbs) fun mode(hz: Int, sbs: Boolean): Int fun modeForStep(step: Int): Int? } diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuCapture.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuCapture.kt new file mode 100644 index 0000000000..a22f575768 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuCapture.kt @@ -0,0 +1,175 @@ +package com.droiddeck.launcher.glasses + +import android.app.Activity +import android.content.Context +import android.content.ContextWrapper +import android.graphics.Color +import android.graphics.PorterDuff +import android.graphics.SurfaceTexture +import android.os.Build +import android.os.Looper +import android.view.Choreographer +import android.view.Surface +import android.view.View +import android.view.WindowManager +import android.view.inspector.WindowInspector +import kotlin.math.min +import kotlin.math.roundToInt + +class GlassesMenuCapture(private val activity: Activity, private val onSize: (Int, Int) -> Unit, + private val onFailure: (Throwable) -> Unit = {}) : Choreographer.FrameCallback { + private var texture: SurfaceTexture? = null + private var surface: Surface? = null + private var running = false + private var framePending = false + private var lastFrameNs = Long.MIN_VALUE + private var failures = 0 + private var bufferWidth = 0 + private var bufferHeight = 0 + private val basePosition = IntArray(2) + private val windowPosition = IntArray(2) + + fun attach(texture: SurfaceTexture, surface: Surface) { + checkMainThread() + this.texture = texture + this.surface = surface + bufferWidth = 0 + bufferHeight = 0 + failures = 0 + lastFrameNs = Long.MIN_VALUE + } + + fun start() { + checkMainThread() + if (running || activity.isDestroyed || activity.isFinishing) return + running = true + failures = 0 + lastFrameNs = Long.MIN_VALUE + schedule() + } + + fun stop() { + checkMainThread() + running = false + if (framePending) Choreographer.getInstance().removeFrameCallback(this) + framePending = false + } + + override fun doFrame(frameTimeNanos: Long) { + framePending = false + if (!running) return + if (activity.isDestroyed || activity.isFinishing) { + stop() + return + } + if (lastFrameNs == Long.MIN_VALUE || frameTimeNanos - lastFrameNs >= FRAME_INTERVAL_NS) { + lastFrameNs = frameTimeNanos + try { + capture() + failures = 0 + } catch (error: Exception) { + if (++failures >= MAX_FAILURES) { + stop() + onFailure(error) + } + } + } + if (running) schedule() + } + + private fun schedule() { + if (framePending) return + framePending = true + Choreographer.getInstance().postFrameCallback(this) + } + + private fun capture() { + val target = surface ?: return + val input = texture ?: return + val decor = activity.window.decorView + if (!decor.isAttachedToWindow || !decor.isShown) return + val size = captureSize(decor.width, decor.height) ?: return + check(target.isValid) + if (bufferWidth != size.first || bufferHeight != size.second) { + input.setDefaultBufferSize(size.first, size.second) + onSize(size.first, size.second) + bufferWidth = size.first + bufferHeight = size.second + } + val candidates = if (Build.VERSION.SDK_INT >= 29) WindowInspector.getGlobalWindowViews() else emptyList() + val roots = captureRoots(activity, candidates) + val canvas = target.lockHardwareCanvas() + val initialSave = canvas.save() + try { + canvas.drawColor(Color.BLACK, PorterDuff.Mode.SRC) + val scale = min(canvas.width.toFloat() / decor.width, canvas.height.toFloat() / decor.height) + canvas.translate((canvas.width - decor.width * scale) / 2f, (canvas.height - decor.height * scale) / 2f) + canvas.scale(scale, scale) + canvas.clipRect(0, 0, decor.width, decor.height) + decor.getLocationOnScreen(basePosition) + for (root in roots) { + val params = root.layoutParams as? WindowManager.LayoutParams + if (root !== decor && params != null && params.flags and WindowManager.LayoutParams.FLAG_DIM_BEHIND != 0) { + canvas.drawColor(Color.argb((params.dimAmount.coerceIn(0f, 1f) * 255).roundToInt(), 0, 0, 0)) + } + root.getLocationOnScreen(windowPosition) + val saved = canvas.save() + try { + canvas.translate((windowPosition[0] - basePosition[0]).toFloat(), (windowPosition[1] - basePosition[1]).toFloat()) + root.draw(canvas) + } finally { + canvas.restoreToCount(saved) + } + } + } finally { + try { + canvas.restoreToCount(initialSave) + } finally { + target.unlockCanvasAndPost(canvas) + } + } + } + + private fun checkMainThread() { + check(Looper.myLooper() == Looper.getMainLooper()) + } + + internal companion object { + private const val FRAME_INTERVAL_NS = 33_333_334L + private const val MAX_FAILURES = 3 + private const val MAX_EDGE = 1920 + + internal fun captureSize(width: Int, height: Int): Pair? { + if (width <= 0 || height <= 0) return null + val scale = min(1.0, MAX_EDGE.toDouble() / maxOf(width, height)) + return (width * scale).roundToInt().coerceAtLeast(1) to (height * scale).roundToInt().coerceAtLeast(1) + } + + internal fun captureRoots(activity: Activity, candidates: List): List { + val decor = activity.window.decorView + if (activity.window.attributes.flags and WindowManager.LayoutParams.FLAG_SECURE != 0 || + !decor.isAttachedToWindow || !decor.isShown) return emptyList() + if (Build.VERSION.SDK_INT < 29) return listOf(decor) + val display = decor.display?.displayId ?: return listOf(decor) + val token = decor.applicationWindowToken + return listOf(decor) + candidates.filter { root -> + if (root === decor || !root.isAttachedToWindow || !root.isShown || root.display?.displayId != display) return@filter false + val params = root.layoutParams as? WindowManager.LayoutParams ?: return@filter false + if (params.flags and WindowManager.LayoutParams.FLAG_SECURE != 0 || + params.type !in WindowManager.LayoutParams.FIRST_APPLICATION_WINDOW..WindowManager.LayoutParams.LAST_SUB_WINDOW) return@filter false + ownsContext(root.context, activity) || (token != null && root.applicationWindowToken == token) + }.distinct() + } + + private fun ownsContext(context: Context, activity: Activity): Boolean { + var current = context + repeat(16) { + if (current === activity) return true + val next = (current as? ContextWrapper)?.baseContext ?: return false + if (next === current) return false + current = next + } + return false + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuMirror.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuMirror.kt new file mode 100644 index 0000000000..d1b2cc33c4 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuMirror.kt @@ -0,0 +1,219 @@ +package com.droiddeck.launcher.glasses + +import android.app.Activity +import android.app.Application +import android.app.Presentation +import android.os.Bundle +import android.util.Log +import android.view.Display +import android.view.WindowManager +import com.droiddeck.launcher.SessionActivity +import kotlinx.coroutines.CoroutineScope +import kotlinx.coroutines.Dispatchers +import kotlinx.coroutines.SupervisorJob +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.launch + +object GlassesMenuMirror { + private var controller: GlassesMenuController? = null + + fun initialize(app: Application) { + if (controller != null) return + val pose = GlassesMenuPose() + val menus = GlassesMenuController(pose, + display = Glasses::glassesDisplay, + observe = { active -> if (active) Glasses.addPoseObserver(pose) else Glasses.removePoseObserver(pose) }, + create = { activity, display, failure -> MenuPresentation(activity, display, pose, failure) }) + controller = menus + app.registerActivityLifecycleCallbacks(object : Application.ActivityLifecycleCallbacks { + override fun onActivityResumed(activity: Activity) = menus.resume(activity) + override fun onActivityPaused(activity: Activity) = menus.pause(activity) + override fun onActivityDestroyed(activity: Activity) = menus.pause(activity) + override fun onActivityCreated(activity: Activity, state: Bundle?) = Unit + override fun onActivityStarted(activity: Activity) = Unit + override fun onActivityStopped(activity: Activity) = Unit + override fun onActivitySaveInstanceState(activity: Activity, state: Bundle) = Unit + }) + CoroutineScope(SupervisorJob() + Dispatchers.Main.immediate).launch { + combine(Glasses.state, Glasses.settings) { state, settings -> state to settings } + .collect { (state, settings) -> menus.update(state, settings) } + } + } + + fun setSessionMenuVisible(activity: Activity, visible: Boolean) { + controller?.setSessionMenuVisible(activity, visible) + } + + fun recenter() { controller?.recenter() } +} + +internal class GlassesMenuController( + private val pose: GlassesMenuPose, + private val display: () -> Display?, + private val observe: (Boolean) -> Unit, + private val create: (Activity, Display, (Throwable) -> Unit) -> Output, + private val schedule: (() -> Unit) -> Unit = { android.os.Handler(android.os.Looper.getMainLooper()).post(it) }, +) { + interface Output { + fun configure(state: GlassesState, settings: GlassesSettings) + fun show() + fun close() + } + + private var activity: Activity? = null + private val sessionMenus = java.util.WeakHashMap() + private var state = GlassesState() + private var settings = GlassesSettings() + private var output: Output? = null + private var outputDisplay = Display.INVALID_DISPLAY + private var failed = false + private var dismissalRetried = false + private var generation = 0 + + fun resume(owner: Activity) { + if (activity !== owner) close() + activity = owner + failed = false + dismissalRetried = false + reconcile() + } + + fun pause(owner: Activity) { + if (activity !== owner) return + close() + activity = null + } + + fun setSessionMenuVisible(owner: Activity, visible: Boolean) { + if (visible) sessionMenus[owner] = true else sessionMenus.remove(owner) + if (activity === owner) reconcile() + } + + fun update(next: GlassesState, preferences: GlassesSettings) { + val deviceChanged = state.canControl != next.canControl || state.model != next.model + if (deviceChanged) pose.reset() + if (deviceChanged || state.displayId != next.displayId || state.width != next.width || + state.height != next.height || state.sbs != next.sbs || settings != preferences) { + failed = false + dismissalRetried = false + } + state = next + settings = preferences + pose.configure(preferences) + reconcile() + } + + fun recenter() = pose.recenter() + + private fun reconcile() { + val owner = activity + val eligible = owner != null && !owner.isFinishing && !owner.isDestroyed && !owner.isInPictureInPictureMode && + owner.window.attributes.flags and WindowManager.LayoutParams.FLAG_SECURE == 0 && + owner !is com.droiddeck.launcher.QuestXrActivity && + (owner !is SessionActivity || sessionMenus[owner] == true) && + settings.gameOnGlasses && settings.screen3dof && state.usable && state.canControl && state.supportsScreen3dof + val target = if (eligible && !failed) display() else null + if (target == null || owner == null || owner.windowManager.defaultDisplay.displayId == target.displayId) { + close() + return + } + if (outputDisplay != target.displayId) close() + try { + output?.let { it.configure(state, settings); return } + val token = ++generation + val next = create(owner, target) { error -> + if (generation == token) { + close() + if (error is GlassesMenuDisplayStopped && !dismissalRetried) { + dismissalRetried = true + val retry = generation + schedule { if (generation == retry && activity === owner) reconcile() } + } else { + Log.w("GlassesMenu", "Tracked menus are unavailable for this display", error) + failed = true + } + } + } + if (generation != token) { + next.close() + return + } + output = next + outputDisplay = target.displayId + next.configure(state, settings) + if (generation != token) return + observe(true) + next.show() + } catch (error: RuntimeException) { + Log.w("GlassesMenu", "Could not show tracked menus", error) + failed = true + close() + } + } + + private fun close() { + ++generation + val previous = output + output = null + outputDisplay = Display.INVALID_DISPLAY + if (previous != null) { + observe(false) + try { previous.close() } + catch (error: RuntimeException) { Log.w("GlassesMenu", "Could not close tracked menus", error) } + } + } +} + +internal class GlassesMenuDisplayStopped : IllegalStateException("The glasses menu display stopped") + +private class MenuPresentation( + private val owner: Activity, + display: Display, + pose: GlassesMenuPose, + private val onFailure: (Throwable) -> Unit, +) : Presentation(owner, display), GlassesMenuController.Output { + private var closed = false + private val capture: GlassesMenuCapture = GlassesMenuCapture(owner, + onSize = { width, height -> surface.setSourceSize(width, height) }, onFailure = onFailure) + private val surface: GlassesMenuSurface = GlassesMenuSurface(context, pose, onFailure = onFailure) { texture, input -> + if (!closed) { + capture.attach(texture, input) + capture.start() + } + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + window?.addFlags(WindowManager.LayoutParams.FLAG_NOT_FOCUSABLE or + WindowManager.LayoutParams.FLAG_NOT_TOUCHABLE or WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) + setContentView(surface) + } + + override fun configure(state: GlassesState, settings: GlassesSettings) { + surface.configure(settings, state) + val mode = display.mode + val hz = if (state.sbs) settings.sbsHz else settings.refreshHz + val best = display.supportedModes.filter { + it.physicalWidth == mode.physicalWidth && it.physicalHeight == mode.physicalHeight + }.minByOrNull { kotlin.math.abs(it.refreshRate - hz) } + if (best != null) window?.let { it.attributes = it.attributes.apply { preferredDisplayModeId = best.modeId } } + } + + override fun close() { + if (closed) return + closed = true + capture.stop() + surface.close() + dismiss() + } + + override fun onStop() { + capture.stop() + surface.close() + super.onStop() + if (!closed) { + closed = true + onFailure(GlassesMenuDisplayStopped()) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuPose.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuPose.kt new file mode 100644 index 0000000000..d64e2f1236 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuPose.kt @@ -0,0 +1,86 @@ +package com.droiddeck.launcher.glasses + +import com.droiddeck.launcher.gpu.HeadPose + +class GlassesMenuPose internal constructor( + private val spatialEnabled: () -> Boolean = { SpatialTracking.enabled }, + private val spatialView: (Long) -> SpatialPose? = { now -> + synchronized(SpatialTracking.session) { + if (SpatialTracking.session.valid(now)) SpatialTracking.session.view(true) else null + } + }, + private val recenterSpatial: () -> Unit = { SpatialTracking.recenter(true) }, +) : Glasses.PoseSink { + data class Frame( + val rotation: FloatArray, + val position: FloatArray, + val valid: Boolean, + val spatial: Boolean, + ) + + private var tracking = true + private var positional = false + private var reference: HeadPose.Reference? = null + private var latest: FloatArray? = null + private var latestTime = 0L + private var safe = identity() + + @Synchronized fun configure(settings: GlassesSettings) { + if (tracking != settings.headTracking) { + reference = null + safe = identity() + } + tracking = settings.headTracking + positional = settings.positionalTracking + } + + @Synchronized override fun onPose(x: Float, y: Float, z: Float, w: Float, timeNs: Long) { + val norm = x*x + y*y + z*z + w*w + if (!norm.isFinite() || norm !in 0.25f..2.25f || timeNs <= latestTime) return + val matrix = HeadPose.fromGlasses(x, y, z, w) + if (matrix.any { !it.isFinite() }) return + latest = matrix + latestTime = timeNs + } + + @Synchronized fun snapshot(now: Long = System.nanoTime()): Frame { + if (!tracking) return identity() + val spatial = positional && spatialEnabled() + if (spatial) { + val pose = spatialView(now) + val normalized = pose?.rotation?.normalized() + if (pose != null && pose.position.finite() && normalized != null) { + safe = Frame(normalized.matrix(), pose.position.array(), true, true) + return copy(safe) + } + } else { + val matrix = latest + if (matrix != null && latestTime > 0 && now-latestTime in 0..MAX_AGE_NS) { + val anchor = reference ?: HeadPose.recenter(matrix, centerView = true).also { reference = it } + safe = Frame(HeadPose.relative(anchor, matrix), FloatArray(3), true, false) + return copy(safe) + } + } + return copy(safe).copy(valid = false, spatial = spatial) + } + + @Synchronized fun recenter() { + if (positional && spatialEnabled()) recenterSpatial() + else reference = null + } + + @Synchronized fun reset() { + reference = null + latest = null + latestTime = 0L + safe = identity() + } + + private fun copy(frame: Frame) = frame.copy(rotation = frame.rotation.copyOf(), position = frame.position.copyOf()) + + private fun identity() = Frame(HeadPose.IDENTITY.copyOf(), FloatArray(3), false, false) + + companion object { + internal const val MAX_AGE_NS = 100_000_000L + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuSurface.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuSurface.kt new file mode 100644 index 0000000000..cefe3d9329 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuSurface.kt @@ -0,0 +1,291 @@ +package com.droiddeck.launcher.glasses + +import android.content.Context +import android.graphics.SurfaceTexture +import android.opengl.GLES11Ext +import android.opengl.GLES20 +import android.opengl.GLSurfaceView +import android.os.Handler +import android.os.Looper +import android.util.Log +import android.view.Surface +import java.nio.ByteBuffer +import java.nio.ByteOrder +import java.util.concurrent.atomic.AtomicBoolean +import java.util.concurrent.atomic.AtomicInteger +import javax.microedition.khronos.egl.EGLConfig +import javax.microedition.khronos.opengles.GL10 +import kotlin.math.tan + +class GlassesMenuSurface( + context: Context, + private val pose: GlassesMenuPose, + private val onFailure: (Throwable) -> Unit = {}, + private val onInput: (SurfaceTexture, Surface) -> Unit, +) : GLSurfaceView(context) { + private data class Scene(val settings: GlassesSettings, val state: GlassesState) + + private val main = Handler(Looper.getMainLooper()) + private val closed = AtomicBoolean() + private val failed = AtomicBoolean() + private val generation = AtomicInteger() + private val pendingFrame = AtomicBoolean() + private val inputLock = Any() + private var inputTexture: SurfaceTexture? = null + private var inputSurface: Surface? = null + @Volatile private var scene = Scene(GlassesSettings(), GlassesState()) + @Volatile private var sourceAspect = 16f / 9f + private val renderer = MenuRenderer() + + init { + setEGLContextClientVersion(2) + setEGLConfigChooser(8, 8, 8, 8, 0, 0) + preserveEGLContextOnPause = true + setRenderer(renderer) + renderMode = RENDERMODE_CONTINUOUSLY + } + + fun configure(settings: GlassesSettings, state: GlassesState) { + pose.configure(settings) + scene = Scene(settings, state) + } + + fun setSourceSize(width: Int, height: Int) { + if (width > 0 && height > 0) sourceAspect = width.toFloat() / height + } + + fun close() { + if (!closed.compareAndSet(false, true)) return + generation.incrementAndGet() + queueEvent { renderer.release() } + } + + override fun onDetachedFromWindow() { + close() + super.onDetachedFromWindow() + // GLSurfaceView may exit its GL thread before queued cleanup is consumed. + releaseInput() + } + + private fun releaseInput() = synchronized(inputLock) { + inputTexture?.setOnFrameAvailableListener(null) + inputSurface?.release() + inputTexture?.release() + inputSurface = null + inputTexture = null + pendingFrame.set(false) + } + + private fun fail(error: Throwable) { + if (!failed.compareAndSet(false, true)) return + generation.incrementAndGet() + Log.e("GlassesMenu", "Menu rendering is unavailable", error) + main.post { if (!closed.get()) onFailure(error) } + } + + private inner class MenuRenderer : Renderer { + private val vertices = ByteBuffer.allocateDirect(8 * 4).order(ByteOrder.nativeOrder()).asFloatBuffer().apply { + put(floatArrayOf(-1f, -1f, 1f, -1f, -1f, 1f, 1f, 1f)); position(0) + } + private val textureMatrix = FloatArray(16) + private var texture = 0 + private var program = 0 + private var width = 1 + private var height = 1 + private var hasFrame = false + private var positionLocation = 0 + private var textureLocation = 0 + private var transformLocation = 0 + private var rotationLocation = IntArray(3) + private var headLocation = 0 + private var screenLocation = 0 + private var opticsLocation = 0 + + override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) { + releaseInput() + texture = 0 + program = 0 + hasFrame = false + if (closed.get() || failed.get()) return + val token = generation.incrementAndGet() + try { + program = linkProgram() + positionLocation = GLES20.glGetAttribLocation(program, "aPosition") + textureLocation = GLES20.glGetUniformLocation(program, "uTexture") + transformLocation = GLES20.glGetUniformLocation(program, "uTextureMatrix") + rotationLocation = IntArray(3) { GLES20.glGetUniformLocation(program, "uRotation$it") } + headLocation = GLES20.glGetUniformLocation(program, "uHead") + screenLocation = GLES20.glGetUniformLocation(program, "uScreen") + opticsLocation = GLES20.glGetUniformLocation(program, "uOptics") + val names = IntArray(1) + GLES20.glGenTextures(1, names, 0) + texture = names[0] + check(texture != 0) { "Could not allocate the menu texture" } + GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture) + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_LINEAR) + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR) + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE) + GLES20.glTexParameteri(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE) + checkGl("initialize menu texture") + val incoming = SurfaceTexture(texture) + val surface = synchronized(inputLock) { + inputTexture = incoming + Surface(incoming).also { inputSurface = it } + } + incoming.setOnFrameAvailableListener({ + if (!closed.get() && generation.get() == token) pendingFrame.set(true) + }, main) + main.post { + if (!closed.get() && !failed.get() && generation.get() == token) onInput(incoming, surface) + } + } catch (e: RuntimeException) { + fail(e) + release() + } + } + + override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) { + this.width = width.coerceAtLeast(1) + this.height = height.coerceAtLeast(1) + GLES20.glViewport(0, 0, this.width, this.height) + } + + override fun onDrawFrame(gl: GL10?) { + if (closed.get() || failed.get()) return + GLES20.glClearColor(0.015f, 0.015f, 0.02f, 1f) + GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT) + if (program == 0) return + if (pendingFrame.getAndSet(false)) synchronized(inputLock) { + inputTexture?.let { + try { + it.updateTexImage() + it.getTransformMatrix(textureMatrix) + checkGl("update menu texture") + hasFrame = true + } catch (e: RuntimeException) { + fail(e) + release() + return + } + } + } + if (!hasFrame) return + val current = scene + val frame = pose.snapshot() + val halfWidth = current.settings.screenWidthDm.coerceIn(5, 200) / 20f + val distance = current.settings.screenDistanceDm.coerceIn(5, 200) / 10f + val mono = !current.state.sbs + val fov = current.state.verticalFovDeg.takeIf { it.isFinite() }?.coerceIn(20f, 140f) ?: 23.3f + val tangent = tan(Math.toRadians(fov.toDouble()) / 2).toFloat() + GLES20.glUseProgram(program) + GLES20.glActiveTexture(GLES20.GL_TEXTURE0) + GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, texture) + GLES20.glUniform1i(textureLocation, 0) + GLES20.glUniformMatrix4fv(transformLocation, 1, false, textureMatrix, 0) + for (row in 0..2) GLES20.glUniform3fv(rotationLocation[row], 1, frame.rotation, row * 3) + GLES20.glUniform3fv(headLocation, 1, frame.position, 0) + GLES20.glUniform3f(screenLocation, halfWidth, distance, sourceAspect) + GLES20.glUniform4f(opticsLocation, tangent, width.toFloat() / height / (if (mono) 1f else 2f), + if (mono) 0f else IPD_METERS / 2f, if (mono) 1f else 0f) + vertices.position(0) + GLES20.glEnableVertexAttribArray(positionLocation) + GLES20.glVertexAttribPointer(positionLocation, 2, GLES20.GL_FLOAT, false, 0, vertices) + GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, 4) + GLES20.glDisableVertexAttribArray(positionLocation) + } + + fun release() { + releaseInput() + if (texture != 0) GLES20.glDeleteTextures(1, intArrayOf(texture), 0) + if (program != 0) GLES20.glDeleteProgram(program) + texture = 0 + program = 0 + hasFrame = false + } + + private fun checkGl(operation: String) { + val error = GLES20.glGetError() + check(error == GLES20.GL_NO_ERROR) { "Could not $operation: GL error 0x${error.toString(16)}" } + } + + private fun shader(type: Int, source: String): Int { + val shader = GLES20.glCreateShader(type) + GLES20.glShaderSource(shader, source) + GLES20.glCompileShader(shader) + val status = IntArray(1) + GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, status, 0) + if (status[0] == 0) { + val error = GLES20.glGetShaderInfoLog(shader) + GLES20.glDeleteShader(shader) + throw IllegalStateException(error) + } + return shader + } + + private fun linkProgram(): Int { + val vertex = shader(GLES20.GL_VERTEX_SHADER, VERTEX) + var fragment = 0 + var linked = 0 + try { + fragment = shader(GLES20.GL_FRAGMENT_SHADER, FRAGMENT) + linked = GLES20.glCreateProgram() + GLES20.glAttachShader(linked, vertex) + GLES20.glAttachShader(linked, fragment) + GLES20.glLinkProgram(linked) + val status = IntArray(1) + GLES20.glGetProgramiv(linked, GLES20.GL_LINK_STATUS, status, 0) + check(status[0] != 0) { GLES20.glGetProgramInfoLog(linked) } + return linked + } catch (e: RuntimeException) { + if (linked != 0) GLES20.glDeleteProgram(linked) + throw e + } finally { + GLES20.glDeleteShader(vertex) + if (fragment != 0) GLES20.glDeleteShader(fragment) + } + } + } + + companion object { + internal const val IPD_METERS = 0.064f + private const val VERTEX = """ + attribute vec2 aPosition; + varying vec2 vUv; + void main() { + gl_Position = vec4(aPosition, 0.0, 1.0); + vUv = aPosition * 0.5 + 0.5; + } + """ + private const val FRAGMENT = """ + #extension GL_OES_EGL_image_external : require + precision highp float; + uniform samplerExternalOES uTexture; + uniform mat4 uTextureMatrix; + uniform vec3 uRotation0, uRotation1, uRotation2, uHead, uScreen; + uniform vec4 uOptics; + varying vec2 vUv; + vec3 rotate(vec3 v) { + return vec3(dot(uRotation0, v), dot(uRotation1, v), dot(uRotation2, v)); + } + void main() { + bool mono = uOptics.w > 0.5; + float eye = mono || vUv.x < 0.5 ? 0.0 : 1.0; + vec2 local = vec2(mono ? vUv.x : vUv.x * 2.0 - eye, 1.0 - vUv.y); + vec2 ray = (local - 0.5) * vec2(uOptics.y, 1.0) * (2.0 * uOptics.x); + vec3 direction = rotate(vec3(ray.x, -ray.y, -1.0)); + vec3 origin = uHead + rotate(vec3((eye < 0.5 ? -1.0 : 1.0) * uOptics.z, 0.0, 0.0)); + vec3 color = vec3(0.015, 0.015, 0.02); + if (direction.z < -0.0001) { + float distance = (-uScreen.y - origin.z) / direction.z; + vec3 hit = origin + direction * distance; + vec2 source = vec2(hit.x / uScreen.x, -hit.y * uScreen.z / uScreen.x) * 0.5 + 0.5; + if (distance > 0.0 && all(greaterThanEqual(source, vec2(0.0))) && all(lessThanEqual(source, vec2(1.0)))) { + vec2 uv = (uTextureMatrix * vec4(source.x, 1.0 - source.y, 0.0, 1.0)).xy; + color = texture2D(uTexture, uv).rgb; + } + } + gl_FragColor = vec4(color, 1.0); + } + """ + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt index 4edc730b24..4cd7f0a6d3 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesRendering.kt @@ -4,13 +4,32 @@ import com.droiddeck.launcher.gpu.Cardboard /** Share the actual picture mode with settings so controls match the rendered view. */ internal object GlassesRendering { - enum class Picture { FLAT, VIRTUAL_SCREEN, STEREO } + enum class Picture { FLAT, DUPLICATED, VIRTUAL_SCREEN, STEREO } - fun outputHz(settings: GlassesSettings, state: GlassesState): Int = - if (state.sbs) if (state.sbs90) settings.sbsHz else 60 else settings.refreshHz + fun native30HzAvailable(settings: GlassesSettings, state: GlassesState): Boolean = + state.usable && state.supports30Hz && settings.gameOnGlasses - fun mirrorRefreshLimit(settings: GlassesSettings, state: GlassesState, outputActive: Boolean): Int = - if (state.usable && !outputActive) outputHz(settings, state) else 0 + fun refreshRates(settings: GlassesSettings, state: GlassesState): List = buildList { + if (native30HzAvailable(settings, state)) add(30) + add(60) + if (!state.sbs || state.sbs90) add(90) + if (!state.sbs) add(120) + } + + fun outputHz(settings: GlassesSettings, state: GlassesState): Int { + val requested = if (state.sbs) settings.sbsHz else settings.refreshHz + return when { + requested == 30 -> if (native30HzAvailable(settings, state)) 30 else 60 + state.sbs && !state.sbs90 -> 60 + else -> requested + } + } + + fun mirrorRefreshLimit(settings: GlassesSettings, state: GlassesState, outputActive: Boolean): Int { + if (!state.usable || outputActive) return 0 + val hz = outputHz(settings, state) + return if (hz == 30 && kotlin.math.abs(state.hz - 30f) >= 0.5f) 60 else hz + } fun fpsLimit(requested: Int, mirrorRefreshLimit: Int): Int = when { mirrorRefreshLimit <= 0 -> requested @@ -22,14 +41,12 @@ internal object GlassesRendering { outputActive || (steamVrRunning && state.usable) fun picture(settings: GlassesSettings, stereoDisplay: Boolean, steamVrRunning: Boolean): Picture = - when (settings.picture3d) { - GlassesSettings.PICTURE_SCREEN -> Picture.VIRTUAL_SCREEN - GlassesSettings.PICTURE_SBS -> Picture.STEREO - else -> when { - steamVrRunning -> Picture.STEREO - stereoDisplay -> Picture.VIRTUAL_SCREEN - else -> Picture.FLAT - } + when { + steamVrRunning -> Picture.STEREO + settings.picture3d == GlassesSettings.PICTURE_SCREEN -> Picture.VIRTUAL_SCREEN + settings.picture3d == GlassesSettings.PICTURE_SBS -> Picture.STEREO + stereoDisplay -> Picture.DUPLICATED + else -> Picture.FLAT } fun cardboard( @@ -55,12 +72,17 @@ internal object GlassesRendering { if (picture == Picture.FLAT) return Cardboard.OFF return Cardboard( enabled = true, - source = if (picture == Picture.STEREO) Cardboard.SOURCE_SBS else Cardboard.SOURCE_SCREEN, + source = when (picture) { + Picture.STEREO -> Cardboard.SOURCE_SBS + Picture.DUPLICATED -> Cardboard.SOURCE_FLAT + else -> Cardboard.SOURCE_SCREEN + }, viewer = Cardboard.Viewer.VITURE.id, ipdMm = base.ipdMm, screenWidthDm = settings.screenWidthDm, screenDistanceDm = settings.screenDistanceDm, - headTracking = settings.headTracking && state.canControl, + headTracking = settings.headTracking && state.canControl && + (picture == Picture.VIRTUAL_SCREEN || steamVrRunning), mono = !state.sbs, ) } diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesScreen.kt b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesScreen.kt index ae14cfb569..c15e9c623f 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/GlassesScreen.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/GlassesScreen.kt @@ -13,10 +13,12 @@ import android.view.WindowManager import android.widget.FrameLayout import kotlin.math.abs -class GlassesScreen(context: Context, display: Display, refreshHz: Int, private val callback: SurfaceHolder.Callback) : Presentation(context, display) { +class GlassesScreen(context: Context, display: Display, refreshHz: Int, private val callback: SurfaceHolder.Callback, resolution: GlassesResolution? = null) : Presentation(context, display) { val surfaceView = SurfaceView(getContext()) + internal val trackingRecovery = com.droiddeck.launcher.ui.TrackingRecoveryView(getContext()) val holder: SurfaceHolder get() = surfaceView.holder private var wantHz = refreshHz + private var wantResolution = resolution val hz: Float get() = display.mode.refreshRate @@ -24,14 +26,16 @@ class GlassesScreen(context: Context, display: Display, refreshHz: Int, private super.onCreate(savedInstanceState) val root = FrameLayout(context).apply { setBackgroundColor(Color.BLACK) } root.addView(surfaceView, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) + root.addView(trackingRecovery, FrameLayout.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)) setContentView(root) window?.addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON) applyMode() surfaceView.holder.addCallback(callback) } - fun prefer(hz: Int) { + fun prefer(hz: Int, resolution: GlassesResolution? = null) { wantHz = hz + wantResolution = resolution // A 2D/SBS transition can replace the active mode without changing Hz. applyMode() } @@ -39,9 +43,14 @@ class GlassesScreen(context: Context, display: Display, refreshHz: Int, private private fun applyMode() { val w = window ?: return val current = display.mode - val best = display.supportedModes.filter { + val target = wantResolution + val width = target?.width?.times(if (current.physicalWidth >= 3000) 2 else 1) ?: current.physicalWidth + val height = target?.height ?: current.physicalHeight + val requested = display.supportedModes.filter { it.physicalWidth == width && it.physicalHeight == height } + val candidates = requested.ifEmpty { display.supportedModes.filter { it.physicalWidth == current.physicalWidth && it.physicalHeight == current.physicalHeight - }.minByOrNull { abs(it.refreshRate - wantHz) } ?: return + } } + val best = candidates.minByOrNull { abs(it.refreshRate - wantHz) } ?: return if (w.attributes.preferredDisplayModeId != best.modeId) { Log.i("GlassesScreen", "display ${display.displayId}: prefer mode ${best.modeId} " + "${best.physicalWidth}x${best.physicalHeight}@${best.refreshRate} (requested $wantHz Hz)") diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/HandGestures.kt b/app/src/main/java/com/droiddeck/launcher/glasses/HandGestures.kt new file mode 100644 index 0000000000..dae8c4cb6e --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/HandGestures.kt @@ -0,0 +1,48 @@ +package com.droiddeck.launcher.glasses + +import kotlin.math.* + +internal class HandGestures(private val rightHand: Boolean) { + private var grip = false + private var last: SpatialHand? = null + var lastOutcome = HandObservationOutcome.LANDMARK_COUNT_INVALID; private set + fun reset() { grip = false; last = null } + fun resetAfterRejection(outcome: HandObservationOutcome) { + if (outcome != HandObservationOutcome.PALM_MOTION_REJECTED) reset() + } + private fun reject(outcome: HandObservationOutcome): SpatialHand? { lastOutcome = outcome; return null } + fun estimate(points: List, worldFromCamera: SpatialPose, time: Long, + leftImage: List? = null, rightImage: List? = null): SpatialHand? { + if (points.size != 21) return reject(HandObservationOutcome.LANDMARK_COUNT_INVALID) + val p = points.map { it?.takeIf(SpatialVector::finite) } + val wrist = p[0] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING) + val index = p[5] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING) + val middle = p[9] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING) + val ring = p[13] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING) + val little = p[17] ?: return reject(HandObservationOutcome.PALM_LANDMARK_MISSING) + val width = (index-little).length() + if (width !in 0.035f..0.13f) return reject(HandObservationOutcome.PALM_WIDTH_INVALID) + val forward = (middle-wrist).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID) + val lateral = (if (rightHand) little-index else index-little).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID) + val up = lateral.cross(forward).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID) + val right = forward.cross(up).normalized() ?: return reject(HandObservationOutcome.PALM_BASIS_INVALID) + val palm = (wrist+index+middle+ring+little) * 0.2f + val pose = worldFromCamera * SpatialPose(palm,SpatialRotation.fromBasis(right,up,forward * -1f)) + last?.let { old -> + val dt=(time-old.timeNs)/1e9f + if (dt>0 && dt<0.2f && (pose.position-old.pose.position).length()>0.08f+dt*3f) + return reject(HandObservationOutcome.PALM_MOTION_REJECTED) + } + val stereo = if (leftImage != null || rightImage != null) + StereoFingerGestures.estimate(leftImage,rightImage,grip) else null + val triggerValid = stereo?.triggerValid ?: (p[4] != null && p[8] != null) + val trigger = stereo?.trigger ?: if (triggerValid) ((0.55f-(p[4]!!-p[8]!!).length()/width)/0.35f).coerceIn(0f,1f) else 0f + val gripValid = stereo?.gripValid ?: listOf(12,16,20).all { p[it] != null } + val closed = if (stereo == null && gripValid) listOf(12 to 9,16 to 13,20 to 17).count { (tip,base) -> + (p[tip]!!-wrist).length() < (p[base]!!-wrist).length()*1.35f + } else 0 + grip=stereo?.grip ?: (gripValid && if(grip) closed>=2 else closed==3) + lastOutcome = HandObservationOutcome.ACCEPTED + return SpatialHand(pose,time,true,trigger,grip,triggerValid,gripValid).also { last=it } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/HandImageBuffer.kt b/app/src/main/java/com/droiddeck/launcher/glasses/HandImageBuffer.kt new file mode 100644 index 0000000000..b6aa9844a5 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/HandImageBuffer.kt @@ -0,0 +1,57 @@ +package com.droiddeck.launcher.glasses + +import android.graphics.Bitmap +import com.google.mediapipe.framework.image.ByteBufferImageBuilder +import com.google.mediapipe.framework.image.MPImage +import java.nio.ByteBuffer + +internal class HandImageBuffer { + companion object { + const val PREPROCESSING = "raw-grayscale-rgb" + } + private var pixels = ByteBuffer.allocateDirect(0) + private var source = IntArray(0) + private var rgb = ByteArray(0) + + private fun allocateRgb(count: Int) { + if (rgb.size != count * 3) { + rgb = ByteArray(count * 3) + pixels = ByteBuffer.allocateDirect(rgb.size) + } + } + + fun image(grayscale: ByteArray, width: Int, height: Int): MPImage { + require(width > 0 && height > 0 && width.toLong() * height == grayscale.size.toLong()) + allocateRgb(grayscale.size) + var index = 0 + for (value in grayscale) { + rgb[index++] = value + rgb[index++] = value + rgb[index++] = value + } + return image(width, height) + } + + fun image(grayscale: Bitmap): MPImage { + val count = grayscale.width * grayscale.height + if (source.size != count) source = IntArray(count) + allocateRgb(count) + grayscale.getPixels(source, 0, grayscale.width, 0, 0, grayscale.width, grayscale.height) + var index = 0 + for (pixel in source) { + val value = (pixel ushr 16).toByte() + rgb[index++] = value + rgb[index++] = value + rgb[index++] = value + } + return image(grayscale.width, grayscale.height) + } + + private fun image(width: Int, height: Int): MPImage { + pixels.clear() + pixels.put(rgb) + pixels.rewind() + // MediaPipe applies the model metadata's float normalization to these RGB bytes. + return ByteBufferImageBuilder(pixels, width, height, MPImage.IMAGE_FORMAT_RGB).build() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/HandInferenceSchedule.kt b/app/src/main/java/com/droiddeck/launcher/glasses/HandInferenceSchedule.kt new file mode 100644 index 0000000000..7e55f273fe --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/HandInferenceSchedule.kt @@ -0,0 +1,72 @@ +package com.droiddeck.launcher.glasses + +internal class HandInferenceSchedule( + private val stableFrames: Int = 3, + private val discoveryIntervalMs: Long = 240, + private val maximumGapMs: Long = 400 +) { + init { + require(stableFrames > 0) + require(discoveryIntervalMs > 0 && maximumGapMs >= discoveryIntervalMs) + } + + private var lastFrameMs = -1L + private var selectedAtMs = -1L + private var selectedMaximum = 2 + private var lastSearchMs = -1L + private var candidateSide = -1 + private var consistentFrames = 0 + private var trackingSide = -1 + + fun select(timestampMs: Long): Int { + if (timestampMs < 0) { + reset() + return 2 + } + if (selectedAtMs >= 0 || lastFrameMs >= 0 && + (timestampMs <= lastFrameMs || timestampMs - lastFrameMs > maximumGapMs)) reset() + val maximum = if (trackingSide >= 0 && lastSearchMs >= 0 && + timestampMs - lastSearchMs < discoveryIntervalMs) 1 else 2 + lastFrameMs = timestampMs + selectedAtMs = timestampMs + selectedMaximum = maximum + if (maximum == 2) lastSearchMs = timestampMs + return maximum + } + + fun observe(timestampMs: Long, leftSides: List, rightSides: List, + leftRawCount: Int = leftSides.size, rightRawCount: Int = rightSides.size) { + if (timestampMs < 0 || selectedAtMs != timestampMs) { + reset() + return + } + selectedAtMs = -1L + val side = leftSides.singleOrNull() ?: -1 + val consistent = leftRawCount == 1 && rightRawCount == 1 && side in 0..1 && + rightSides.singleOrNull() == side + if (!consistent || selectedMaximum == 1 && side != trackingSide) { + forgetHand() + return + } + if (candidateSide != side) { + candidateSide = side + consistentFrames = 0 + } + consistentFrames = minOf(stableFrames, consistentFrames + 1) + if (consistentFrames >= stableFrames) trackingSide = side + } + + fun reset() { + lastFrameMs = -1L + selectedAtMs = -1L + selectedMaximum = 2 + lastSearchMs = -1L + forgetHand() + } + + private fun forgetHand() { + candidateSide = -1 + consistentFrames = 0 + trackingSide = -1 + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/HandModel.kt b/app/src/main/java/com/droiddeck/launcher/glasses/HandModel.kt new file mode 100644 index 0000000000..c1bcaaa342 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/HandModel.kt @@ -0,0 +1,10 @@ +package com.droiddeck.launcher.glasses + +internal enum class HandModel(val asset: String, val sha256: String) { + FULL("models/hand_landmarker.task", "fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1"), + LITE("models/hand_landmarker_lite.task", "173c0f47ecee7e935bd4a1e93aa580756b4180c1307c07d709313e82c28672c8"); + + companion object { + val DEFAULT = FULL + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/HandProcessingRate.kt b/app/src/main/java/com/droiddeck/launcher/glasses/HandProcessingRate.kt new file mode 100644 index 0000000000..f6859b4a73 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/HandProcessingRate.kt @@ -0,0 +1,48 @@ +package com.droiddeck.launcher.glasses + +internal class HandProcessingRate { + var permille = 500 + private set + private var processingMs = Double.NaN + private var headroomSamples = 0 + + fun observe(processingNs: Long, observationAgeNs: Long, trackingHealthy: Boolean): Int { + if (!trackingHealthy || processingNs <= 0 || observationAgeNs < 0) return reset() + val measuredMs = processingNs / 1_000_000.0 + val ageMs = observationAgeNs / 1_000_000.0 + processingMs = if (processingMs.isNaN()) measuredMs else processingMs + 0.2 * (measuredMs - processingMs) + if (measuredMs >= 80 || ageMs >= 140) { + permille = 500 + headroomSamples = 0 + return permille + } + val reduced = when { + permille > 500 && processingMs > 1000.0 / 15 -> 500 + permille == 800 && processingMs > 50 -> 600 + else -> permille + } + if (reduced != permille) { + permille = reduced + headroomSamples = 0 + return permille + } + val enoughHeadroom = when (permille) { + 500 -> processingMs <= 55 && ageMs <= 110 + 600 -> processingMs <= 40 && ageMs <= 90 + else -> false + } + headroomSamples = if (enoughHeadroom) headroomSamples + 1 else 0 + if (headroomSamples >= 8) { + permille = if (permille == 500) 600 else 800 + headroomSamples = 0 + } + return permille + } + + fun reset(): Int { + permille = 500 + processingMs = Double.NaN + headroomSamples = 0 + return permille + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/HandTrackingMetrics.kt b/app/src/main/java/com/droiddeck/launcher/glasses/HandTrackingMetrics.kt new file mode 100644 index 0000000000..bb02d28f23 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/HandTrackingMetrics.kt @@ -0,0 +1,107 @@ +package com.droiddeck.launcher.glasses + +internal enum class HandObservationOutcome { + ACCEPTED, DISABLED, CALIBRATION_REQUIRED, CLOCK_NOT_READY, HEAD_TRACKING_INVALID, + CAMERA_NOT_SYNCHRONIZED, STALE_OBSERVATION, INFERENCE_UNAVAILABLE, + NO_MATCHING_DETECTION, AMBIGUOUS_HANDEDNESS, ONE_CAMERA_ONLY, STEREO_REJECTED, + LANDMARK_COUNT_INVALID, PALM_LANDMARK_MISSING, PALM_WIDTH_INVALID, PALM_BASIS_INVALID, + PALM_MOTION_REJECTED, WRIST_LANDMARK_MISSING, WRIST_MOTION_REJECTED +} + +internal data class HandObservationDiagnostic( + val outcome: HandObservationOutcome, + val reconstructedPalmLandmarks: List = emptyList(), + val triggerEstimate: Float = 0f, + val triggerGeometryValid: Boolean = false, + val gripEstimate: Boolean = false, + val gripGeometryValid: Boolean = false, + val positionSource: String = "none" +) { + val accepted get() = outcome == HandObservationOutcome.ACCEPTED + val triggerValid get() = accepted && triggerGeometryValid + val gripValid get() = accepted && gripGeometryValid +} + +internal data class HandSideMetrics( + val observations: Long, + val accepted: Long, + val triggerValid: Long, + val gripValid: Long, + val triggerAboveClickThreshold: Long, + val triggerReleased: Long, + val gripPressed: Long, + val trackingLosses: Long, + val triggerLosses: Long, + val gripLosses: Long, + val maximumConsecutiveRejected: Long, + val outcomes: Map +) + +internal data class HandTrackingMetricSnapshot( + val processedPairs: Long, + val inferencePairs: Long, + val left: HandSideMetrics, + val right: HandSideMetrics +) + +internal class HandTrackingMetrics { + private class Side { + val outcomes = LongArray(HandObservationOutcome.entries.size) + var triggerValid = 0L + var gripValid = 0L + var triggerAboveClickThreshold = 0L + var triggerReleased = 0L + var gripPressed = 0L + var trackingLosses = 0L + var triggerLosses = 0L + var gripLosses = 0L + var consecutiveRejected = 0L + var maximumConsecutiveRejected = 0L + var wasAccepted = false + var wasTriggerValid = false + var wasGripValid = false + + fun observe(sample: HandObservationDiagnostic) { + outcomes[sample.outcome.ordinal]++ + if (sample.triggerValid) { + triggerValid++ + if (sample.triggerEstimate > 0.65f) triggerAboveClickThreshold++ + if (sample.triggerEstimate < 0.25f) triggerReleased++ + } + if (sample.gripValid) { + gripValid++ + if (sample.gripEstimate) gripPressed++ + } + if (wasAccepted && !sample.accepted) trackingLosses++ + if (wasTriggerValid && !sample.triggerValid) triggerLosses++ + if (wasGripValid && !sample.gripValid) gripLosses++ + consecutiveRejected = if (sample.accepted) 0 else consecutiveRejected + 1 + maximumConsecutiveRejected = maxOf(maximumConsecutiveRejected, consecutiveRejected) + wasAccepted = sample.accepted + wasTriggerValid = sample.triggerValid + wasGripValid = sample.gripValid + } + + fun snapshot() = HandSideMetrics(outcomes.sum(), outcomes[HandObservationOutcome.ACCEPTED.ordinal], + triggerValid, gripValid, triggerAboveClickThreshold, triggerReleased, gripPressed, trackingLosses, triggerLosses, gripLosses, + maximumConsecutiveRejected, HandObservationOutcome.entries.filter { outcomes[it.ordinal] > 0 } + .associateWith { outcomes[it.ordinal] }) + } + + private val sides = Array(2) { Side() } + private var lastSequence = 0L + private var processedPairs = 0L + private var inferencePairs = 0L + + fun observe(sequence: Long, inferred: Boolean, left: HandObservationDiagnostic, + right: HandObservationDiagnostic) { + if (sequence <= lastSequence) return + lastSequence = sequence + processedPairs++ + if (inferred) inferencePairs++ + sides[0].observe(left) + sides[1].observe(right) + } + + fun snapshot() = HandTrackingMetricSnapshot(processedPairs, inferencePairs, sides[0].snapshot(), sides[1].snapshot()) +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/JoyConFlowGate.kt b/app/src/main/java/com/droiddeck/launcher/glasses/JoyConFlowGate.kt new file mode 100644 index 0000000000..7b6c2ce083 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/JoyConFlowGate.kt @@ -0,0 +1,16 @@ +package com.droiddeck.launcher.glasses + +import kotlin.math.hypot + +internal object JoyConFlowGate { + const val MAX_SEED_AGE_NS = 750_000_000L + fun fresh(seed: Long, previous: Long, now: Long) = seed > 0 && previous > 0 && + now > previous && now - previous <= 200_000_000L && now - seed in 0..MAX_SEED_AGE_NS + + fun point(x: Double, y: Double, backX: Double, backY: Double, oldX: Double, oldY: Double, + error: Float, forward: Boolean, backward: Boolean, width: Int, height: Int): Boolean = + forward && backward && error.isFinite() && error in 0f..20f && + x.isFinite() && y.isFinite() && backX.isFinite() && backY.isFinite() && + x >= 3 && y >= 3 && x < width - 3 && y < height - 3 && + hypot(backX - oldX, backY - oldY) <= 1.5 && hypot(x - oldX, y - oldY) <= 100 +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/JoyConWristPosition.kt b/app/src/main/java/com/droiddeck/launcher/glasses/JoyConWristPosition.kt new file mode 100644 index 0000000000..74f3237eb6 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/JoyConWristPosition.kt @@ -0,0 +1,26 @@ +package com.droiddeck.launcher.glasses + +internal class JoyConWristPosition { + private var last: SpatialHand? = null + var lastOutcome = HandObservationOutcome.WRIST_LANDMARK_MISSING; private set + + fun reset() { last = null } + + private fun reject(outcome: HandObservationOutcome): SpatialHand? { + lastOutcome = outcome + return null + } + + fun estimate(points: List, worldFromCamera: SpatialPose, time: Long): SpatialHand? { + val wrist = points.firstOrNull()?.takeIf(SpatialVector::finite) + ?: return reject(HandObservationOutcome.WRIST_LANDMARK_MISSING) + val pose = worldFromCamera * SpatialPose(wrist) + last?.let { old -> + val dt = (time - old.timeNs) / 1e9f + if (dt <= 0 || (dt < .2f && (pose.position - old.pose.position).length() > .08f + dt * 3f)) + return reject(HandObservationOutcome.WRIST_MOTION_REJECTED) + } + lastOutcome = HandObservationOutcome.ACCEPTED + return SpatialHand(pose, time, true, triggerValid = false, gripValid = false).also { last = it } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/LumaRgbDiagnostic.kt b/app/src/main/java/com/droiddeck/launcher/glasses/LumaRgbDiagnostic.kt new file mode 100644 index 0000000000..6a483a1a04 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/LumaRgbDiagnostic.kt @@ -0,0 +1,160 @@ +package com.droiddeck.launcher.glasses + +import android.Manifest +import android.app.PendingIntent +import android.app.Service +import android.content.Context +import android.content.Intent +import android.content.pm.PackageManager +import android.hardware.usb.UsbManager +import android.os.IBinder +import android.util.AtomicFile +import org.json.JSONObject +import java.io.File + +internal object LumaRgbDiagnostic { + private fun file(context: Context) = AtomicFile(File(context.filesDir, "spatial/rgb-diagnostic.json")) + private fun save(context: Context, value: JSONObject) { + val target = file(context) + target.baseFile.parentFile?.mkdirs() + val output = target.startWrite() + try { + output.write(value.toString().toByteArray(Charsets.UTF_8)) + target.finishWrite(output) + } catch (e: Exception) { target.failWrite(output); throw e } + } + + private fun expired(value: JSONObject, nowMs: Long) = nowMs-value.optLong("startedMs") !in + 0..value.optLong("timeoutMs",15_000).coerceIn(15_000,45_000) + + private fun workerAlive(context: Context, pid: Int): Boolean = pid > 0 && pid != android.os.Process.myPid() && + runCatching { + File("/proc/$pid/cmdline").readText().substringBefore('\u0000') == "${context.packageName}:rgb_diagnostic" + }.getOrDefault(false) + + internal fun resolveStatus(value: JSONObject, nowMs: Long, workerAlive: Boolean): JSONObject { + val pending = value.optString("state") == "capturing" + if (workerAlive && !expired(value,nowMs)) { + if (!pending) value.put("resultState",value.optString("state")).put("phase","finishing") + return value.put("state","capturing").put("busy",true) + } + if (pending && (expired(value,nowMs) || value.optInt("workerPid") > 0 && !workerAlive)) + value.put("state","failed").put("message","RGB capture worker stopped or timed out") + return value.put("busy",workerAlive || value.optString("state") == "capturing") + } + + fun status(context: Context): JSONObject = runCatching { + val value = JSONObject(file(context).readFully().toString(Charsets.UTF_8)) + val now = android.os.SystemClock.elapsedRealtime() + val pid = value.optInt("workerPid") + if (expired(value,now) && workerAlive(context,pid)) android.os.Process.killProcess(pid) + resolveStatus(value,now,workerAlive(context,pid)) + }.getOrElse { JSONObject().put("state", "idle") } + + @Synchronized fun capture(context: Context, transport: String = "sdk", width: Int = 640, height: Int = 480, + fps: Int = 30, durationMs: Int = 5000): JSONObject { + require(transport in listOf("sdk","uvc") && width in 160..1920 && height in 120..1080 && + fps in 5..30 && durationMs in 1000..30000) { "Invalid RGB capture options" } + val app = context.applicationContext + val old = status(app) + if (old.optBoolean("busy")) return old + val usb = app.getSystemService(Context.USB_SERVICE) as UsbManager + val device = usb.deviceList.values.singleOrNull { it.vendorId == 0x0c45 && it.productId == 0x636b } + fun state(value: String, message: String): JSONObject { + val result = JSONObject().put("state", value).put("message", message) + save(app, result) + return result + } + if (!Glasses.state.value.spatialConnected || device == null) + return state("unavailable", "Connect the Luma Ultra glasses and RGB camera") + if (app.checkSelfPermission(Manifest.permission.CAMERA) != PackageManager.PERMISSION_GRANTED) + return state("permission_required", "Grant Android camera permission to capture the RGB camera") + if (!usb.hasPermission(device)) { + val intent = Intent("${app.packageName}.RGB_DIAGNOSTIC_PERMISSION").setPackage(app.packageName) + val pending = PendingIntent.getBroadcast(app, 3, intent, PendingIntent.FLAG_IMMUTABLE or PendingIntent.FLAG_UPDATE_CURRENT) + usb.requestPermission(device, pending) + return state("permission_required", "Approve the USB camera permission, then request the capture again") + } + val result = JSONObject().put("state", "capturing").put("startedMs", android.os.SystemClock.elapsedRealtime()) + .put("timeoutMs",durationMs+15000).put("transport",transport) + save(app, result) + try { app.startService(Intent(app, LumaRgbCaptureService::class.java).putExtra("device", device.deviceName) + .putExtra("transport",transport).putExtra("width",width).putExtra("height",height) + .putExtra("fps",fps).putExtra("durationMs",durationMs)) } + catch (e: Exception) { return state("failed", e.message ?: e.toString()) } + return result + } + + internal fun perform(context: Context, deviceName: String, transport: String, width: Int, height: Int, + fps: Int, durationMs: Int) { + val folder=File(context.filesDir,"spatial/rgb-captures/${System.nanoTime()}").apply { mkdirs() } + val startedMs=android.os.SystemClock.elapsedRealtime() + val workerPid=android.os.Process.myPid() + save(context,JSONObject().put("state","capturing").put("path",folder.path) + .put("startedMs",startedMs).put("timeoutMs",durationMs+15000) + .put("transport",transport).put("workerPid",workerPid)) + val result = try { + val direct=transport=="uvc" + check(if(direct) UvcRgbDiagnostic.available else VitureSdk.available) { "Requested RGB transport is unavailable" } + val usb = context.getSystemService(Context.USB_SERVICE) as UsbManager + val device = checkNotNull(usb.deviceList[deviceName]) { "RGB camera disconnected" } + check(device.vendorId == 0x0c45 && device.productId == 0x636b && usb.hasPermission(device)) + val connection = checkNotNull(usb.openDevice(device)) { "Could not open RGB camera" } + val metadata=LongArray(if(direct) 14 else 7) + val jpeg=try { + File(folder,"usb-descriptors.bin").writeBytes(connection.rawDescriptors) + android.os.ParcelFileDescriptor.open(File(folder,"usb.log"), + android.os.ParcelFileDescriptor.MODE_CREATE or android.os.ParcelFileDescriptor.MODE_TRUNCATE or + android.os.ParcelFileDescriptor.MODE_WRITE_ONLY).use { log -> + if(direct) UvcRgbDiagnostic.nativeSnapshot(connection.fileDescriptor,width,height,fps,durationMs,metadata,log.fd) + else VitureSdk.nativeRgbSnapshot(device.vendorId,device.productId,connection.fileDescriptor,metadata,log.fd) + } + } finally { connection.close() } + check(jpeg != null) { "RGB camera returned no frame ($transport status ${metadata[4]}, callbacks ${metadata[5]})" } + File(folder,"rgb.jpg").writeBytes(jpeg) + val info=JSONObject().put("state","completed").put("path",folder.path) + .put("width",metadata[0]).put("height",metadata[1]).put("timestampNs",metadata[2]) + .put("sequence",metadata[3]).put("callbacks",metadata[5]).put("source","Luma Ultra UVC RGB") + .put("receiptNs",metadata[6]).put("timingBasis","Host callback receipt; not exposure time") + .put("snapshotAcquired",true) + if(direct) { + val health=UvcStreamHealth.assess(metadata,fps,durationMs) + info.put("firstReceiptNs",metadata[7]).put("maxFrameGapMs",health.maximumGapMs) + .put("completeFrames",metadata[9]).put("invalidFrames",metadata[10]).put("bytes",metadata[11]) + .put("observationEndNs",metadata[12]).put("tailFrameAgeMs",metadata[13]/1e6) + .put("observationMs",health.observationMs).put("observedFps",health.observedFps) + .put("streamHealthy",health.healthy) + } + info + } catch (e: Exception) { JSONObject().put("state","failed").put("snapshotAcquired",false) + .put("message",e.message ?: e.toString()) } + result.put("path",folder.path).put("transport",transport).put("requestedWidth",width).put("requestedHeight",height) + .put("requestedFps",fps).put("durationMs",durationMs).put("workerPid",workerPid) + .put("startedMs",startedMs).put("timeoutMs",durationMs+15000) + if (transport == "uvc" && !result.has("streamHealthy")) result.put("streamHealthy",false) + File(folder,"frame.json").writeText(result.toString()) + save(context,result) + } +} + +class LumaRgbCaptureService : Service() { + private var running = false + override fun onBind(intent: Intent?): IBinder? = null + override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int { + if (!running) { + running = true + Thread({ + try { LumaRgbDiagnostic.perform(this,intent?.getStringExtra("device") ?: "", + intent?.getStringExtra("transport") ?: "sdk",intent?.getIntExtra("width",640) ?: 640, + intent?.getIntExtra("height",480) ?: 480,intent?.getIntExtra("fps",30) ?: 30, + intent?.getIntExtra("durationMs",5000) ?: 5000) } + finally { + stopSelf() + // SDK 2.4.0 can crash while cancelling failed USB transfers; isolate each diagnostic. + android.os.Process.killProcess(android.os.Process.myPid()) + } + }, "luma-rgb-diagnostic").start() + } + return START_NOT_STICKY + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/SpatialMeasurements.kt b/app/src/main/java/com/droiddeck/launcher/glasses/SpatialMeasurements.kt new file mode 100644 index 0000000000..bacb781baf --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/SpatialMeasurements.kt @@ -0,0 +1,36 @@ +package com.droiddeck.launcher.glasses + +import com.droiddeck.launcher.R +import java.util.Locale +import kotlin.math.roundToInt + +internal object SpatialMeasurements { + fun height(centimeters: Int): String { + val tenths = (centimeters / 2.54 * 10).roundToInt() + return String.format(Locale.getDefault(), "%d cm (%d ft %.1f in)", centimeters, tenths / 120, tenths % 120 / 10.0) + } + + fun distance(meters: Float): String = String.format( + Locale.getDefault(), "%.1f m (%.1f ft)", meters, meters / 0.3048f) + + fun validation(meters: Float): String = String.format( + Locale.getDefault(), "%.1f cm (%.2f in)", meters * 100, meters / 0.0254f) +} + +internal enum class CalibrationDistance(val meters: Float, val labelRes: Int) { + INCHES_12(0.3048f, R.string.spatial_distance_12in), + CENTIMETERS_30(0.3f, R.string.spatial_distance_30cm), + INCHES_20(0.508f, R.string.spatial_distance_20in), + CENTIMETERS_50(0.5f, R.string.spatial_distance_50cm), +} + +internal data class SpatialCalibrationProgress( + val collecting: Boolean = false, + val views: Int = 0, + val fitted: Boolean = false, + val solving: Boolean = false, + val capturing: Boolean = false, + val captureMessage: String? = null, + val validating: Boolean = false, + val validationMessage: String? = null, +) diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/SpatialPose.kt b/app/src/main/java/com/droiddeck/launcher/glasses/SpatialPose.kt new file mode 100644 index 0000000000..6d037fd0c2 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/SpatialPose.kt @@ -0,0 +1,278 @@ +package com.droiddeck.launcher.glasses + +import kotlin.math.* + +data class SpatialVector(val x: Float = 0f, val y: Float = 0f, val z: Float = 0f) { + operator fun plus(b: SpatialVector) = SpatialVector(x + b.x, y + b.y, z + b.z) + operator fun minus(b: SpatialVector) = SpatialVector(x - b.x, y - b.y, z - b.z) + operator fun times(s: Float) = SpatialVector(x * s, y * s, z * s) + fun dot(b: SpatialVector) = x * b.x + y * b.y + z * b.z + fun cross(b: SpatialVector) = SpatialVector(y * b.z - z * b.y, z * b.x - x * b.z, x * b.y - y * b.x) + fun length() = sqrt(dot(this)) + fun normalized() = length().takeIf { it > 1e-6f }?.let { this * (1f / it) } + fun finite() = x.isFinite() && y.isFinite() && z.isFinite() + fun array() = floatArrayOf(x, y, z) +} + +data class SpatialRotation(val x: Float = 0f, val y: Float = 0f, val z: Float = 0f, val w: Float = 1f) { + fun normalized(): SpatialRotation? { + val n = sqrt(x*x + y*y + z*z + w*w) + return if (n.isFinite() && n in 0.5f..1.5f) SpatialRotation(x/n, y/n, z/n, w/n) else null + } + fun inverse() = SpatialRotation(-x, -y, -z, w) + operator fun times(b: SpatialRotation) = SpatialRotation( + w*b.x + x*b.w + y*b.z - z*b.y, w*b.y - x*b.z + y*b.w + z*b.x, + w*b.z + x*b.y - y*b.x + z*b.w, w*b.w - x*b.x - y*b.y - z*b.z) + fun apply(v: SpatialVector): SpatialVector { + val q = SpatialVector(x, y, z) + val t = q.cross(v) * 2f + return v + t * w + q.cross(t) + } + fun matrix() = floatArrayOf( + 1-2*(y*y+z*z), 2*(x*y-z*w), 2*(x*z+y*w), + 2*(x*y+z*w), 1-2*(x*x+z*z), 2*(y*z-x*w), + 2*(x*z-y*w), 2*(y*z+x*w), 1-2*(x*x+y*y)) + fun yaw(): SpatialRotation { + val forward = apply(SpatialVector(0f, 0f, -1f)) + val a = if (forward.x*forward.x + forward.z*forward.z < 1e-8f) { + val right = apply(SpatialVector(x = 1f)) + atan2(-right.z, right.x) / 2 + } else atan2(-forward.x, -forward.z) / 2 + return SpatialRotation(y = sin(a), w = cos(a)) + } + companion object { + fun fromBasis(right: SpatialVector, up: SpatialVector, back: SpatialVector): SpatialRotation { + val m = floatArrayOf(right.x, up.x, back.x, right.y, up.y, back.y, right.z, up.z, back.z) + val trace = m[0] + m[4] + m[8] + val q = if (trace > 0) { + val s = sqrt(trace + 1) * 2 + SpatialRotation((m[7]-m[5])/s, (m[2]-m[6])/s, (m[3]-m[1])/s, s/4) + } else { + val i = if (m[0] > m[4] && m[0] > m[8]) 0 else if (m[4] > m[8]) 1 else 2 + val j = (i+1)%3; val k = (i+2)%3 + val s = sqrt(1 + m[i*3+i] - m[j*3+j] - m[k*3+k]) * 2 + val v = FloatArray(3) + v[i] = s/4; v[j] = (m[j*3+i]+m[i*3+j])/s; v[k] = (m[k*3+i]+m[i*3+k])/s + SpatialRotation(v[0], v[1], v[2], (m[k*3+j]-m[j*3+k])/s) + } + return q.normalized() ?: SpatialRotation() + } + } +} + +data class SpatialPose(val position: SpatialVector = SpatialVector(), val rotation: SpatialRotation = SpatialRotation()) { + fun inverse(): SpatialPose { + val r = rotation.inverse() + return SpatialPose(r.apply(position * -1f), r) + } + operator fun times(b: SpatialPose) = SpatialPose(position + rotation.apply(b.position), rotation * b.rotation) + companion object { + fun fromSdk(v: FloatArray): SpatialPose? { + if (v.size != 7 || v.any { !it.isFinite() }) return null + val q = SpatialRotation(v[4], v[5], v[6], v[3]).normalized() ?: return null + return SpatialPose(SpatialVector(v[0], v[1], v[2]), q) + } + } +} + +data class SpatialSample(val pose: SpatialPose, val timeNs: Long, val generation: Long, val valid: Boolean) +data class SpatialHand(val pose: SpatialPose = SpatialPose(), val timeNs: Long = 0, val valid: Boolean = false, + val trigger: Float = 0f, val grip: Boolean = false, + val triggerValid: Boolean = valid, val gripValid: Boolean = valid) { + fun flags() = if (!valid) 0 else 1 or (if (triggerValid) 2 else 0) or (if (gripValid) 4 else 0) +} + +class SpatialSession { + var generation: Long = 0; private set + var originGeneration: Long = 0; private set + var trackingFrameGeneration: Long = 0; private set + var needsRecenter = false; private set + val recenterPending: Boolean get() = pendingRecenter != null + private var pendingRecenter: Boolean? = null + private var recoveryAnchor: SpatialSample? = null + private var head: SpatialSample? = null + private var lastStable: SpatialSample? = null + private var vrOrigin: SpatialPose? = null + private var screenOrigin: SpatialPose? = null + private var hands = arrayOf(SpatialHand(), SpatialHand()) + private val gestureEpochs = IntArray(4) + private val gestureEligible = BooleanArray(4) + private var inputsAfterNs = 0L + private var height = 1.6f + private val history = ArrayDeque() + + @Synchronized fun reset(connection: Long, eyeHeight: Float, requireSetup: Boolean = false) { + generation = connection; height = eyeHeight.takeIf { it.isFinite() }?.coerceIn(0.5f, 2.5f) ?: 1.6f + originGeneration++; trackingFrameGeneration++; head = null; lastStable = null; vrOrigin = null; screenOrigin = null + history.clear() + pendingRecenter = null; recoveryAnchor = null + hands = arrayOf(SpatialHand(), SpatialHand()); needsRecenter = requireSetup + gestureEpochs.fill(0); gestureEligible.fill(false) + inputsAfterNs = 0L + } + @Synchronized fun accept(sample: SpatialSample): Boolean { + if (sample.generation != generation || sample.timeNs <= (head?.timeNs ?: 0)) return false + val previous = head + if (previous != null && sample.timeNs-previous.timeNs > 100_000_000L) invalidateHeadInputs(sample.timeNs) + val rotation = sample.pose.rotation.normalized() + val current = sample.copy(pose = sample.pose.copy(rotation = rotation ?: SpatialRotation()), + valid = sample.valid && sample.pose.position.finite() && rotation != null) + head = current + if (!current.valid) { + recoveryAnchor = null; invalidateHeadInputs(current.timeNs); return false + } + lastStable?.let { + val d = (current.pose.position - it.pose.position).length() + val a = current.pose.rotation; val b = it.pose.rotation + if (!needsRecenter && (d > 0.5f || abs(a.x*b.x+a.y*b.y+a.z*b.z+a.w*b.w) < 0.9238795f)) { + needsRecenter = true; trackingFrameGeneration++ + } + } + pendingRecenter?.let { screen -> + val anchor = recoveryAnchor + val a = current.pose.rotation; val b = anchor?.pose?.rotation ?: a + if (anchor == null || previous?.valid != true || current.timeNs-previous.timeNs > 100_000_000L || + (current.pose.position-anchor.pose.position).length() > 0.05f || + abs(a.x*b.x+a.y*b.y+a.z*b.z+a.w*b.w) < 0.9961947f) { + recoveryAnchor = current + } else if (current.timeNs-anchor.timeNs >= 250_000_000L) { + applyRecenter(screen, current) + } + } + if (needsRecenter || recenterPending) { invalidateHeadInputs(current.timeNs); return false } + lastStable = current + history.addLast(current) + while (history.size > 512) history.removeFirst() + if (vrOrigin == null) vrOrigin = SpatialPose(current.pose.position - SpatialVector(y = height), current.pose.rotation.yaw()) + if (screenOrigin == null) screenOrigin = current.pose + return true + } + @Synchronized fun setFloor(eyeHeight: Float, now: Long = System.nanoTime()) { + if (!eyeHeight.isFinite()) return + height = eyeHeight.coerceIn(0.5f, 2.5f) + val p = head?.takeIf { it.valid && now-it.timeNs in 0..100_000_000L }?.pose ?: return + vrOrigin = SpatialPose(p.position - SpatialVector(y = height), p.rotation.yaw()) + if (needsRecenter) { history.clear(); screenOrigin = p } + lastStable = head; needsRecenter = false; pendingRecenter = null; recoveryAnchor = null + originGeneration++; invalidateHeadInputs(now) + } + @Synchronized fun recenter(screen: Boolean, now: Long = System.nanoTime()) { + val current = head?.takeIf { it.valid && now-it.timeNs in 0..100_000_000L } + if (current == null || needsRecenter || recenterPending) { + if (pendingRecenter == null) recoveryAnchor = null + pendingRecenter = screen + invalidateHeadInputs(now) + return + } + applyRecenter(screen, current) + } + private fun applyRecenter(screen: Boolean, current: SpatialSample) { + val p = current.pose + if (vrOrigin == null) vrOrigin = SpatialPose(p.position - SpatialVector(y = height), p.rotation.yaw()) + if (screenOrigin == null) screenOrigin = p + if (needsRecenter) { + vrOrigin = SpatialPose(p.position - SpatialVector(y = height), p.rotation.yaw()) + screenOrigin = p; originGeneration++; history.clear() + } + if (screen) screenOrigin = p else { + val floor = vrOrigin?.position?.y ?: (p.position.y-height) + vrOrigin = SpatialPose(SpatialVector(p.position.x, floor, p.position.z), p.rotation.yaw()) + originGeneration++ + } + lastStable = current; needsRecenter = false; pendingRecenter = null; recoveryAnchor = null + invalidateHeadInputs(current.timeNs) + } + @Synchronized fun view(screen: Boolean): SpatialPose? = lastStable?.pose?.let { + (if (screen) screenOrigin else vrOrigin)?.inverse()?.times(it) + } + @Synchronized fun latest() = head + @Synchronized fun poseAt(time: Long, connection: Long): SpatialPose? { + if (connection != generation || needsRecenter || recenterPending) return null + return history.minByOrNull { abs(it.timeNs-time) }?.takeIf { abs(it.timeNs-time) <= 12_000_000L }?.pose + } + @Synchronized fun valid(now: Long) = !needsRecenter && !recenterPending && head?.let { it.valid && now-it.timeNs in 0..100_000_000L } == true + @Synchronized internal fun isCurrentTrackingFrame(connection: Long, frame: Long, clock: () -> Long = System::nanoTime): Boolean = + connection == generation && frame == trackingFrameGeneration && valid(clock()) + @Synchronized fun setHands(connection: Long, left: SpatialHand, right: SpatialHand) { + if (connection != generation || needsRecenter || recenterPending) return + val next = arrayOf(left, right) + for (index in 0..1) { + val oldTime = hands[index].timeNs + val hand = next[index] + if (oldTime > 0 && (hand.timeNs < oldTime || hand.timeNs-oldTime > HandObservation.MAX_AGE_NS)) + invalidateInputs(index) + updateInputs(index, hand, head?.valid == true && usableHand(hand) && hand.timeNs > inputsAfterNs) + } + hands = next + } + @Synchronized fun hand(index: Int, now: Long): SpatialHand { + val h = hands[index] + val origin = vrOrigin + val current = origin != null && usableHand(h) && valid(now) && now-h.timeNs in 0..HandObservation.MAX_AGE_NS + updateInputs(index, h, current && h.timeNs > inputsAfterNs) + return if (origin == null) SpatialHand() else h.copy(pose = origin.inverse() * h.pose, valid = current, + triggerValid = h.triggerValid && gestureEligible[index*2], gripValid = h.gripValid && gestureEligible[index*2+1]) + } + @Synchronized fun inputEpochs(): Int { + var packed = 0 + for (index in gestureEpochs.indices) packed = packed or (gestureEpochs[index] shl (index*8)) + return packed + } + private fun usableHand(hand: SpatialHand): Boolean { + val q = hand.pose.rotation + val norm = q.x*q.x+q.y*q.y+q.z*q.z+q.w*q.w + return hand.valid && hand.timeNs > 0 && hand.pose.position.finite() && norm > 0.99f && norm < 1.01f + } + private fun updateInputs(index: Int, hand: SpatialHand, valid: Boolean) { + updateInput(index*2, valid && hand.triggerValid && hand.trigger.isFinite() && hand.trigger in 0f..1f) + updateInput(index*2+1, valid && hand.gripValid) + } + private fun updateInput(index: Int, eligible: Boolean) { + if (gestureEligible[index] && !eligible) gestureEpochs[index] = (gestureEpochs[index]+1) and 0xff + gestureEligible[index] = eligible + } + private fun invalidateInputs(index: Int? = null) { + if (index == null) for (gesture in gestureEligible.indices) updateInput(gesture, false) + else { updateInput(index*2, false); updateInput(index*2+1, false) } + } + private fun invalidateHeadInputs(time: Long) { + inputsAfterNs = maxOf(inputsAfterNs, time) + hands = arrayOf(SpatialHand(), SpatialHand()) + invalidateInputs() + } +} + +internal data class HandObservation(val timeNs: Long, val connection: Long, val trackingFrame: Long) { + fun headPose(session: SpatialSession, cameraSynchronized: Boolean, now: Long? = null): SpatialPose? = synchronized(session) { + val checkedAt=now ?: System.nanoTime() + if (!cameraSynchronized || timeNs <= 0 || checkedAt-timeNs !in 0..MAX_AGE_NS || + !session.isCurrentTrackingFrame(connection, trackingFrame) { checkedAt }) null + else session.poseAt(timeNs, connection) + } + companion object { + const val MAX_AGE_NS = 200_000_000L + } +} + +internal class CameraClock { + private val offsets = ArrayDeque() + private var lastSource = 0L + private var lastReceipt = 0L + fun map(source: Long, receipt: Long): Long? { + if (source <= 0 || receipt <= 0) { + offsets.clear();lastSource=0;lastReceipt=0 + return null + } + val offset = receipt-source + val skipped = lastSource > 0 && source-lastSource > 200_000_000L + val inconsistent = skipped && offsets.minOrNull()?.let { abs(offset-it) > 20_000_000L } == true + if (source <= lastSource || receipt <= lastReceipt || inconsistent) offsets.clear() + lastSource = source;lastReceipt = receipt + offsets.addLast(offset) + while (offsets.size > 64) offsets.removeFirst() + if (offsets.size < 16) return null + val sorted = offsets.sorted() + if (sorted[sorted.size*9/10]-sorted.first() > 20_000_000L) return null + return source+sorted.first() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/SpatialTracking.kt b/app/src/main/java/com/droiddeck/launcher/glasses/SpatialTracking.kt new file mode 100644 index 0000000000..42b476d4fe --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/SpatialTracking.kt @@ -0,0 +1,208 @@ +package com.droiddeck.launcher.glasses + +import android.content.Context +import com.droiddeck.launcher.R +import com.droiddeck.launcher.wayland.WaylandCompositor +import kotlinx.coroutines.flow.MutableStateFlow +import kotlinx.coroutines.flow.asStateFlow +import kotlinx.coroutines.flow.update +import java.nio.ByteBuffer +import java.nio.ByteOrder + +data class SpatialTrackingStatus(val message: String = "", val calibration: Boolean = false, + val frames: Long = 0, val dropped: Long = 0, val processingMs: Float = 0f, + val frameAgeMs: Float = -1f, val cameraHz: Float = 0f, val synchronized: Boolean = false, + val trackingValid: Boolean = false, val needsRecenter: Boolean = false, val recenterPending: Boolean = false, + val handStatus: String = "", val headFresh: Boolean = false, + val cameraFrameDivisor: Int = 1, val rateLimitedFrames: Long = 0, val cameraCopyPermille: Int = 1000, + val calibrationSource: String = "none", val calibrationVerified: Boolean = false) + +object SpatialTracking { + val session = SpatialSession() + private val mutableStatus = MutableStateFlow(SpatialTrackingStatus()) + val status = mutableStatus.asStateFlow() + @Volatile var enabled = false; private set + @Volatile var handsEnabled = false; private set + private var context: Context? = null + private var engine: StereoHandEngine? = null + private var diagnosticsEnabled = false + private val buffer = ByteBuffer.allocateDirect(176).order(ByteOrder.LITTLE_ENDIAN) + private var lastStatus = 0L + @Volatile private var publisherAttached = false + @Volatile private var spatialSelected = false + private var outputUsesGlasses = true + private var handsSelected = false + private var steadyAimSelected = false + @Volatile private var joyConsSelected = false + internal val joyConsEnabled get() = enabled && joyConsSelected + private var hadSpatialSession = false + internal val selected: Boolean get() = spatialSelected + private fun text(id: Int) = context?.getString(id).orEmpty() + fun initialize(app: Context) { + context = app.applicationContext + mutableStatus.update { it.copy( + message = it.message.ifEmpty { text(R.string.spatial_disabled) }, + handStatus = it.handStatus.ifEmpty { text(R.string.spatial_hands_off) }, + ) } + } + fun attachPublisher(path: String) { + publisherAttached = WaylandCompositor.nativeSetSpatialFile(path) + publish(System.nanoTime()) + } + + internal fun connect(token: Long, generation: Long, identity: String?, spatial: Boolean, eyeHeight: Float, hands: Boolean, + joyCons: Boolean = false, steadyAim: Boolean = false) { + engine?.close(); engine = null + enabled = spatial; handsEnabled = spatial && (hands || joyCons) + spatialSelected = spatial; handsSelected = spatial && hands && !joyCons + joyConsSelected = spatial && joyCons + steadyAimSelected = steadyAim + session.reset(generation, eyeHeight, spatial && hadSpatialSession) + hadSpatialSession = hadSpatialSession || spatial + if (spatial) context?.let { engine = StereoHandEngine(it, token, generation, identity) } + mutableStatus.value = SpatialTrackingStatus(if (spatial) text(R.string.spatial_wait_stable) else text(R.string.spatial_disabled)) + engine?.setEnabled(handsEnabled) + engine?.diagnostics(diagnosticsEnabled) + publish(System.nanoTime()) + } + internal fun disconnect() { + enabled = false; handsEnabled = false + session.reset(session.generation + 1, 1.6f) + publish(System.nanoTime()) + engine?.close(); engine = null + mutableStatus.value = SpatialTrackingStatus(text(R.string.spatial_disconnected)) + publish(System.nanoTime()) + } + @Synchronized internal fun useLegacyTracking() { + spatialSelected = false; handsSelected = false; joyConsSelected = false + publish(System.nanoTime()) + } + @Synchronized internal fun setOutputUsesGlasses(on: Boolean) { + if (outputUsesGlasses == on) return + outputUsesGlasses = on + publish(System.nanoTime()) + } + @Synchronized internal fun accept(values: FloatArray, time: Long, generation: Long, valid: Boolean) { + if (!enabled || generation != session.generation) return + val pose = SpatialPose.fromSdk(values) + session.accept(SpatialSample(pose ?: SpatialPose(), time, generation, valid && pose != null)) + publish(time) + if (time-lastStatus > 250_000_000L) { + lastStatus = time + refreshStatus(time) + } + } + @Synchronized fun refreshStatus(now: Long? = null) { + val checkedAt = now ?: System.nanoTime() + val valid = session.valid(checkedAt) + val pending = session.recenterPending + val recenter = session.needsRecenter + val fresh = session.latest()?.let { it.valid && checkedAt-it.timeNs in 0..100_000_000L } == true + mutableStatus.update { it.copy(trackingValid = valid, needsRecenter = recenter, recenterPending = pending, headFresh = fresh, + handStatus = engine?.handStatus?.message ?: text(R.string.spatial_hands_off), + message = when { + !enabled -> text(R.string.spatial_tracking_off) + pending -> text(R.string.spatial_recenter_pending) + !fresh -> text(R.string.spatial_tracking_lost) + recenter -> text(R.string.spatial_origin_changed) + else -> text(R.string.spatial_active) + }) } + } + @Synchronized fun setControllers(hands: Boolean, joyCons: Boolean) { + handsSelected = hands && !joyCons + joyConsSelected = joyCons + handsEnabled = enabled && (hands || joyCons) + session.setHands(session.generation, SpatialHand(), SpatialHand()) + engine?.setEnabled(handsEnabled) + publish(System.nanoTime()) + } + @Synchronized fun setSteadyHandAim(on: Boolean) { + steadyAimSelected = on + publish(System.nanoTime()) + } + fun setFloor(height: Float) { session.setFloor(height); refreshStatus(); publish(System.nanoTime()) } + fun recenter(screen: Boolean) { session.recenter(screen); refreshStatus(); publish(System.nanoTime()) } + fun diagnostics(on: Boolean) { diagnosticsEnabled = on; engine?.diagnostics(on) } + fun calibrationStart() { engine?.startCalibration() } + fun calibrationCapture() { engine?.captureCalibration() } + fun calibrationSolve() { engine?.solveCalibration() } + fun calibrationValidate(distanceMeters: Float) { engine?.validateCalibration(distanceMeters) } + fun captureDiagnostic() { engine?.recordDiagnostic() } + fun setGpu(gpu: Boolean) { engine?.setGpu(gpu) } + fun setHandModel(lite: Boolean) { engine?.setModel(lite) } + fun setHandHalfRate(halfRate: Boolean) { engine?.setHalfRate(halfRate) } + fun setHandCpuParallel(parallel: Boolean) { engine?.setCpuParallel(parallel) } + fun setHandAdaptiveInput(adaptive: Boolean) { engine?.setAdaptiveInput(adaptive) } + fun setHandScheduledTracking(scheduled: Boolean) { engine?.setScheduledTracking(scheduled) } + internal fun handLiteEnabled() = (engine?.model ?: HandModel.DEFAULT) == HandModel.LITE + internal fun handHalfRateEnabled() = engine?.halfRateInput ?: true + internal fun handAdaptiveInputEnabled() = engine?.adaptiveInput ?: true + fun benchmarkSavedCapture(id: String) { checkNotNull(engine) { "Connect glasses and enable positional tracking" }.benchmarkSavedCapture(id) } + internal fun diagnosticFrame() = engine?.preview + internal fun diagnosticMessage() = engine?.message ?: text(R.string.spatial_connect_hint) + internal fun calibrationProgress() = engine?.calibrationProgress ?: SpatialCalibrationProgress() + internal fun gpuEnabled() = engine?.gpu ?: false + fun diagnosticStatus(): org.json.JSONObject { + val now=System.nanoTime();val sample=session.latest();val state=status.value;val progress=calibrationProgress() + return org.json.JSONObject().put("enabled",enabled).put("valid",session.valid(now)).put("needsRecenter",session.needsRecenter) + .put("joyConTracking",joyConsSelected) + .put("steadyHandAim",handsSelected && steadyAimSelected) + .put("positionEstimator",if (joyConsSelected) "joycon-wrist" else "full-palm") + .put("recenterPending",session.recenterPending) + .put("handMaxAgeMs",HandObservation.MAX_AGE_NS / 1_000_000) + .put("handGpuEnabled",gpuEnabled()).put("handInferenceBackend",engine?.inferenceBackend ?: "not initialized") + .put("handModel",(engine?.model ?: HandModel.DEFAULT).name).put("handHalfRate",handHalfRateEnabled()) + .put("handImagePreprocessing",HandImageBuffer.PREPROCESSING) + .put("handLensCorrection",engine?.lensCorrection ?: "none") + .put("handCpuParallel",engine?.cpuParallel ?: true) + .put("handAdaptiveInput",handAdaptiveInputEnabled()).put("handScheduledTracking",engine?.scheduledTracking ?: true) + .put("handInputRatePermille",engine?.inputRatePermille ?: 500) + .put("handBenchmark",engine?.benchmark) + .put("calibrationViews",progress.views).put("calibrationCollecting",progress.collecting) + .put("capturePending",progress.capturing).put("captureMessage",progress.captureMessage) + .put("calibrationFitted",progress.fitted).put("validationPending",progress.validating).put("validationMessage",progress.validationMessage) + .put("calibrationIdentityAvailable",engine?.hasStableIdentity == true).put("handTracking",engine?.handStatus?.json()) + .put("calibrationSource",engine?.calibrationSource ?: "none").put("calibrationVerified",engine?.calibrationVerified == true) + .put("generation",session.generation).put("origin",session.originGeneration) + .put("ageMs",sample?.let { (now-it.timeNs)/1e6 } ?: -1.0) + .put("position",sample?.pose?.position?.array()?.let { org.json.JSONArray(it.toList()) }) + .put("message",state.message).put("camera",diagnosticMessage()).put("frames",state.frames).put("dropped",state.dropped) + .put("processingMs",state.processingMs.toDouble()).put("calibrated",state.calibration) + .put("frameAgeMs",state.frameAgeMs.toDouble()).put("cameraHz",state.cameraHz.toDouble()).put("synchronized",state.synchronized) + .put("cameraFrameDivisor",state.cameraFrameDivisor).put("rateLimitedFrames",state.rateLimitedFrames) + .put("cameraCopyPermille",state.cameraCopyPermille) + .put("leftValid",session.hand(0,now).valid).put("rightValid",session.hand(1,now).valid) + } + internal fun statistics(calibrated: Boolean, frames: Long, dropped: Long, ms: Float, age: Float, hz: Float, synchronized: Boolean, + frameDivisor: Int, rateLimited: Long, copyPermille: Int = 1000) { + mutableStatus.update { it.copy(calibration = calibrated, frames = frames, dropped = dropped, processingMs = ms, + frameAgeMs=age,cameraHz=hz,synchronized=synchronized,cameraFrameDivisor=frameDivisor, + rateLimitedFrames=rateLimited,cameraCopyPermille=copyPermille, + calibrationSource=engine?.calibrationSource ?: "none",calibrationVerified=engine?.calibrationVerified == true) } + } + @Synchronized internal fun publish(now: Long) { + synchronized(session) { + val hands = Array(2) { session.hand(it, now) } + buffer.clear() + buffer.putInt(0x53504444).putInt(4).putInt(176).putInt(0) + buffer.putLong(session.generation).putLong(session.originGeneration) + val modes = (if (spatialSelected) 1 else 0) or (if (handsSelected) 2 else 0) or + (if (joyConsSelected) 4 else 0) or (if (handsSelected && steadyAimSelected) 8 else 0) + buffer.putInt(if (outputUsesGlasses) modes else 0).putInt(session.inputEpochs()) + putPose(session.view(false) ?: SpatialPose(), session.latest()?.timeNs ?: 0, if(session.valid(now)) 1 else 0) + for (i in 0..1) { + val hand = hands[i] + putPose(hand.pose, hand.timeNs, hand.flags()) + buffer.putFloat(if (hand.valid && hand.triggerValid) hand.trigger else 0f) + .putInt(if (hand.valid && hand.gripValid && hand.grip) 1 else 0) + } + buffer.flip() + if (publisherAttached) WaylandCompositor.nativePublishSpatial(buffer) + } + } + private fun putPose(p: SpatialPose, time: Long, flags: Int) { + buffer.putLong(time).putFloat(p.position.x).putFloat(p.position.y).putFloat(p.position.z) + buffer.putFloat(p.rotation.x).putFloat(p.rotation.y).putFloat(p.rotation.z).putFloat(p.rotation.w) + buffer.putInt(flags) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/SteamVrSpatialGate.kt b/app/src/main/java/com/droiddeck/launcher/glasses/SteamVrSpatialGate.kt new file mode 100644 index 0000000000..848541b1ad --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/SteamVrSpatialGate.kt @@ -0,0 +1,32 @@ +package com.droiddeck.launcher.glasses + +internal class SteamVrSpatialGate(private val settleMs: Long = 2_000) { + private var waiting = false + private var running = false + var deadline: Long? = null + private set + + fun prepare(): Boolean { + if (running || waiting) return false + waiting = true + deadline = null + return true + } + + fun setRunning(on: Boolean, now: Long): Boolean { + if (running == on) return false + running = on + waiting = false + deadline = if (on) now + settleMs else null + return true + } + + fun cancel() { + waiting = false + running = false + deadline = null + } + + fun spatialEnabled(requested: Boolean, now: Long) = + requested && !waiting && (deadline?.let { now >= it } ?: true) +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibration.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibration.kt new file mode 100644 index 0000000000..027f0b92e1 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibration.kt @@ -0,0 +1,300 @@ +package com.droiddeck.launcher.glasses + +import android.content.Context +import com.droiddeck.launcher.R +import org.json.JSONArray +import org.json.JSONObject +import org.opencv.calib3d.Calib3d +import org.opencv.core.* +import org.opencv.objdetect.CharucoBoard +import org.opencv.objdetect.CharucoDetector +import org.opencv.objdetect.Objdetect +import org.opencv.imgproc.Imgproc +import java.io.File +import kotlin.math.* + +internal data class BoardObservation(val objects: Mat, val left: Mat, val right: Mat, val head: SpatialPose) + +internal class CalibrationAlignmentException(context: Context, val deviation: Float) : IllegalArgumentException( + context.getString(R.string.spatial_alignment_error, SpatialMeasurements.validation(deviation))) + +internal class StereoCalibration(val identity: String, val width: Int, val height: Int, val fisheye: Boolean, + val k1: Mat, val d1: Mat, val k2: Mat, val d2: Mat, val r: Mat, val t: Mat, + val cameraToHead: SpatialPose, val error: Double, var verified: Boolean = false, + val bundledBase: Boolean = false) : AutoCloseable { + val readyForTracking get() = verified || bundledBase + val source get() = if (bundledBase && !verified) "luma-ultra-base" else "device" + private val p1 = Mat.zeros(3, 4, CvType.CV_64F) + private val p2 = Mat.zeros(3, 4, CvType.CV_64F) + private val undistortionMaps = Array(2) { arrayOf(Mat(),Mat()) } + init { + val a = Mat.eye(3, 4, CvType.CV_64F) + val b = Mat.zeros(3, 4, CvType.CV_64F) + r.copyTo(b.colRange(0, 3)); t.copyTo(b.col(3)) + val empty = Mat() + Core.gemm(k1, a, 1.0, empty, 0.0, p1); Core.gemm(k2, b, 1.0, empty, 0.0, p2) + a.release(); b.release(); empty.release() + } + fun undistort(src: Mat, dst: Mat, right: Boolean) { + val k = if (right) k2 else k1; val d = if (right) d2 else d1 + val maps=undistortionMaps[if(right) 1 else 0] + if(maps[0].empty()) { + val identity=Mat.eye(3,3,CvType.CV_64F) + try { + if(fisheye) Calib3d.fisheye_initUndistortRectifyMap(k,d,identity,k,src.size(),CvType.CV_16SC2,maps[0],maps[1]) + else Calib3d.initUndistortRectifyMap(k,d,identity,k,src.size(),CvType.CV_16SC2,maps[0],maps[1]) + } finally { identity.release() } + } + Imgproc.remap(src,dst,maps[0],maps[1],Imgproc.INTER_LINEAR) + } + fun triangulateRaw(left: List, right: List): List? { + val points = triangulateLandmarksRaw(left,right) ?: return null + return if(points.any { it == null }) null else points.filterNotNull() + } + fun triangulateLandmarksRaw(left: List, right: List): List? { + if (left.size != right.size || left.isEmpty()) return null + val l=MatOfPoint2f(*left.toTypedArray()); val r=MatOfPoint2f(*right.toTypedArray()) + try { return triangulateRawPoints(l,r) } finally { l.release();r.release() } + } + fun triangulateRaw(left: Mat, right: Mat): List? { + val points = triangulateRawPoints(left,right) ?: return null + return if(points.any { it == null }) null else points.filterNotNull() + } + private fun triangulateRawPoints(left: Mat, right: Mat): List? { + val l=MatOfPoint2f(); val r=MatOfPoint2f(); val identity=Mat.eye(3,3,CvType.CV_64F) + try { + if (fisheye) { + Calib3d.fisheye_undistortPoints(left,l,k1,d1,identity,k1) + Calib3d.fisheye_undistortPoints(right,r,k2,d2,identity,k2) + } else { + val criteria=TermCriteria(TermCriteria.COUNT+TermCriteria.EPS,50,1e-8) + Calib3d.undistortPointsIter(left,l,k1,d1,identity,k1,criteria) + Calib3d.undistortPointsIter(right,r,k2,d2,identity,k2,criteria) + } + return triangulatePoints(l.toList(),r.toList()) + } finally { l.release(); r.release(); identity.release() } + } + fun triangulate(left: List, right: List): List? { + val points = triangulatePoints(left,right) ?: return null + return if(points.any { it == null }) null else points.filterNotNull() + } + private fun triangulatePoints(left: List, right: List): List? { + if (left.size != right.size || left.isEmpty()) return null + val a = Mat(2, left.size, CvType.CV_64F); val b = Mat(2, right.size, CvType.CV_64F); val out = Mat() + try { + a.put(0, 0, *left.map { it.x }.toDoubleArray()); a.put(1, 0, *left.map { it.y }.toDoubleArray()) + b.put(0, 0, *right.map { it.x }.toDoubleArray()); b.put(1, 0, *right.map { it.y }.toDoubleArray()) + Calib3d.triangulatePoints(p1, p2, a, b, out) + val projection1 = DoubleArray(12); val projection2 = DoubleArray(12) + p1.get(0,0,projection1); p2.get(0,0,projection2) + return left.indices.map { i -> + StereoPointValidation.reconstruct(DoubleArray(4) { out.get(it,i)[0] }, + doubleArrayOf(left[i].x,left[i].y),doubleArrayOf(right[i].x,right[i].y),projection1,projection2) + } + } finally { a.release(); b.release(); out.release() } + } + fun save(file: File) { + fun mat(m: Mat) = JSONArray((0 until m.rows()).flatMap { row -> (0 until m.cols()).map { m.get(row,it)[0] } }) + val j = JSONObject().put("version",1).put("identity",identity).put("width",width).put("height",height) + .put("fisheye",fisheye).put("error",error).put("verified",verified) + for ((name,value) in listOf("k1" to k1,"d1" to d1,"k2" to k2,"d2" to d2,"r" to r,"t" to t)) + j.put(name, JSONObject().put("rows",value.rows()).put("cols",value.cols()).put("data",mat(value))) + val p = cameraToHead.position; val q = cameraToHead.rotation + j.put("cameraToHead",JSONArray(listOf(p.x,p.y,p.z,q.w,q.x,q.y,q.z))) + file.parentFile?.mkdirs() + val tmp = File(file.parentFile,file.name+".tmp"); tmp.writeText(j.toString()) + java.nio.file.Files.move(tmp.toPath(),file.toPath(),java.nio.file.StandardCopyOption.REPLACE_EXISTING) + } + override fun close() { (listOf(k1,d1,k2,d2,r,t,p1,p2)+undistortionMaps.flatMap { it.toList() }).forEach { it.release() } } + companion object { + fun load(file: File, identity: String, width: Int, height: Int): StereoCalibration? = + runCatching { StereoCalibrationProfile.parse(file.readText(), identity, width, height)?.let(::fromProfile) }.getOrNull() + + fun fromProfile(profile: StereoCalibrationProfile): StereoCalibration { + val matrices = mutableListOf() + try { + profile.matrices.forEach { data -> + val matrix = Mat(data.rows, data.columns, CvType.CV_64F) + matrices.add(matrix) + matrix.put(0, 0, *data.values) + } + return StereoCalibration(profile.identity, profile.width, profile.height, profile.fisheye, + matrices[0], matrices[1], matrices[2], matrices[3], matrices[4], matrices[5], + profile.cameraToHead, profile.error, profile.verified, profile.bundledBase) + } catch (e: Exception) { + matrices.forEach(Mat::release) + throw e + } + } + } +} + +internal class StereoCalibrator(private val context: Context) : AutoCloseable { + val board = CharucoBoard(Size(5.0,7.0),0.03f,0.022f,Objdetect.getPredefinedDictionary(Objdetect.DICT_4X4_50)) + private val detector = CharucoDetector(board) + val observations = mutableListOf() + var commonCorners: Int = 0; private set + fun detect(left: Mat, right: Mat, head: SpatialPose): BoardObservation? { + val lc=Mat(); val li=Mat(); val rc=Mat(); val ri=Mat() + try { + detector.detectBoard(left,lc,li); detector.detectBoard(right,rc,ri) + val l=(0 until li.rows()).associate { li.get(it,0)[0].toInt() to lc.get(it,0) } + val r=(0 until ri.rows()).associate { ri.get(it,0)[0].toInt() to rc.get(it,0) } + val ids=l.keys.intersect(r.keys).sorted() + commonCorners = ids.size + if (ids.size<12) return null + val objects=MatOfPoint3f(*ids.map { Point3((it%4+1)*0.03,(it/4+1)*0.03,0.0) }.toTypedArray()) + return BoardObservation(objects,MatOfPoint2f(*ids.map { Point(l[it]!![0],l[it]!![1]) }.toTypedArray()), + MatOfPoint2f(*ids.map { Point(r[it]!![0],r[it]!![1]) }.toTypedArray()),head) + } finally { listOf(lc,li,rc,ri).forEach { it.release() } } + } + fun solve(identity: String,width: Int,height: Int): StereoCalibration { + require(observations.size>=24) { context.getString(R.string.spatial_need_views) } + val initial=observations.first().head.rotation + val axes=observations.map { initial.inverse()*it.head.rotation }.map { SpatialVector(it.x,it.y,it.z) } + require(axes.any { a -> axes.any { b -> a.cross(b).length()>0.02f } }) { context.getString(R.string.spatial_need_rotation) } + val training=observations.filterIndexed { i,_ -> i%5!=0 }; val held=observations.filterIndexed { i,_ -> i%5==0 } + val failures = mutableListOf>() + val candidates=listOf(false,true).mapNotNull { fish -> + try { fit(identity,width,height,fish,training,held) } + catch (e: Exception) { + val model = if (fish) "Fisheye" else "Pinhole" + android.util.Log.w("StereoCalibration", "$model calibration failed", e) + failures.add(model to e) + null + } + } + val best=candidates.minByOrNull { it.error } ?: run { + val alignment=failures.map { it.second }.filterIsInstance().minByOrNull { it.deviation } + val reason=alignment?.message ?: failures.joinToString(" ") { (model,e) -> + "$model: ${e.message?.substringBefore('\n') ?: e.javaClass.simpleName}" + } + error(context.getString(R.string.spatial_calibration_error, reason)) + } + candidates.filter { it !== best }.forEach { it.close() } + if(best.error>2.0) { best.close(); error(context.getString(R.string.spatial_reprojection_error, best.error)) } + return best + } + private fun fit(identity: String,w: Int,h: Int,fish: Boolean,train: List,held: List): StereoCalibration { + val k1=Mat.eye(3,3,CvType.CV_64F); val k2=Mat.eye(3,3,CvType.CV_64F) + val d1=Mat.zeros(if(fish) 4 else 5,1,CvType.CV_64F); val d2=d1.clone() + val r=Mat(); val t=Mat(); val objects=train.map { it.objects }; val size=Size(w.toDouble(),h.toDouble()) + fun intrinsic(k: Mat,d: Mat,images: List) { + val rv=mutableListOf(); val tv=mutableListOf() + try { + if(fish) Calib3d.fisheye_calibrate(objects,images,size,k,d,rv,tv,Calib3d.fisheye_CALIB_RECOMPUTE_EXTRINSIC or Calib3d.fisheye_CALIB_FIX_SKEW) + else Calib3d.calibrateCamera(objects,images,size,k,d,rv,tv) + } finally { (rv+tv).forEach { it.release() } } + } + try { + intrinsic(k1,d1,train.map { it.left }); intrinsic(k2,d2,train.map { it.right }) + stereoGeometry(objects,train.map{it.left},train.map{it.right},k1,d1,k2,d2,size,fish,r,t) + require(Core.norm(t) in 0.02..0.3) { context.getString(R.string.spatial_bad_baseline) } + val hr=mutableListOf(); val ht=mutableListOf(); val br=mutableListOf(); val bt=mutableListOf() + val camR=Mat(); val camT=Mat() + try { + for(o in train) { + val rv=Mat(); val tv=Mat(); val rotation=Mat() + boardPose(o.objects,o.left,k1,d1,fish,rv,tv) + Calib3d.Rodrigues(rv,rotation); rv.release(); br.add(rotation); bt.add(tv) + hr.add(matrix(o.head.rotation)); ht.add(vector(o.head.position)) + } + Calib3d.calibrateHandEye(hr,ht,br,bt,camR,camT,Calib3d.CALIB_HAND_EYE_PARK) + require(Core.checkRange(camR) && Core.checkRange(camT) && Core.norm(camT)<0.3) { context.getString(R.string.spatial_need_orientations) } + val cameraToHead=pose(camR,camT) + require(abs(Core.determinant(camR)-1.0)<0.01) { context.getString(R.string.spatial_bad_rotation) } + val boardWorld=held.map { o -> + val rv=Mat();val tv=Mat();val rotation=Mat() + try { + boardPose(o.objects,o.left,k1,d1,fish,rv,tv);Calib3d.Rodrigues(rv,rotation) + o.head*cameraToHead*pose(rotation,tv) + } finally { rv.release();tv.release();rotation.release() } + } + val center=boardWorld.map { it.position }.reduce { a,b -> a+b }*(1f/boardWorld.size) + val drift = boardWorld.maxOf { (it.position-center).length() } + if (drift>=0.05f) throw CalibrationAlignmentException(context,drift) + val orientation=boardWorld.first().rotation + require(boardWorld.all { val q=orientation.inverse()*it.rotation;abs(q.w)>cos(Math.toRadians(8.0)/2) }) { context.getString(R.string.spatial_bad_alignment) } + val error=held.map { reprojection(it,k1,d1,k2,d2,r,t,fish) }.average() + require(error.isFinite()) + return StereoCalibration(identity,w,h,fish,k1,d1,k2,d2,r,t,cameraToHead,error) + } finally { (hr+ht+br+bt+listOf(camR,camT)).forEach { it.release() } } + } catch(e: Exception) { listOf(k1,k2,d1,d2,r,t).forEach { it.release() }; throw e } + } + private fun boardPose(objects: Mat,pixels: Mat,k: Mat,d: Mat,fish: Boolean,rv: Mat,tv: Mat) { + val ok=if(fish) Calib3d.fisheye_solvePnP(objects,pixels,k,d,rv,tv) + else { + val obj=MatOfPoint3f(objects); val img=MatOfPoint2f(pixels); val dist=MatOfDouble(d) + try { Calib3d.solvePnP(obj,img,k,dist,rv,tv) } finally { obj.release(); img.release(); dist.release() } + } + require(ok) + } + private fun reprojection(o: BoardObservation,k1: Mat,d1: Mat,k2: Mat,d2: Mat,r: Mat,t: Mat,fish: Boolean): Double { + val rv=Mat(); val tv=Mat(); val rot=Mat(); val rightR=Mat(); val rightT=Mat(); val rightV=Mat(); val empty=Mat() + val predicted=MatOfPoint2f(); val objectPoints=MatOfPoint3f(o.objects); val dist=MatOfDouble(d2) + try { + boardPose(o.objects,o.left,k1,d1,fish,rv,tv); Calib3d.Rodrigues(rv,rot) + Core.gemm(r,rot,1.0,empty,0.0,rightR); Core.gemm(r,tv,1.0,t,1.0,rightT); Calib3d.Rodrigues(rightR,rightV) + if(fish) Calib3d.fisheye_projectPoints(o.objects,predicted,rightV,rightT,k2,d2) + else Calib3d.projectPoints(objectPoints,rightV,rightT,k2,dist,predicted) + return Core.norm(predicted,o.right,Core.NORM_L2)/sqrt(o.right.rows().toDouble()) + } finally { listOf(rv,tv,rot,rightR,rightT,rightV,empty,predicted,objectPoints,dist).forEach { it.release() } } + } + override fun close() { observations.forEach { listOf(it.objects,it.left,it.right).forEach(Mat::release) }; observations.clear(); detector.clear() } + fun save(file: File, identity: String, width: Int, height: Int) { + fun points(m: Mat) = JSONArray((0 until m.rows()).map { row -> JSONArray(m.get(row,0).toList()) }) + val views = JSONArray(observations.map { o -> + val p=o.head.position; val q=o.head.rotation + JSONObject().put("objects",points(o.objects)).put("left",points(o.left)).put("right",points(o.right)) + .put("head",JSONArray(listOf(p.x,p.y,p.z,q.w,q.x,q.y,q.z))) + }) + val data=JSONObject().put("version",1).put("identity",identity).put("width",width).put("height",height).put("views",views) + file.parentFile?.mkdirs() + val temporary=File(file.parentFile,file.name+".tmp") + temporary.writeText(data.toString()) + java.nio.file.Files.move(temporary.toPath(),file.toPath(),java.nio.file.StandardCopyOption.REPLACE_EXISTING) + } + companion object { + fun load(context: Context, file: File, identity: String, width: Int, height: Int): StereoCalibrator? { + if (!file.isFile) return null + val restored=StereoCalibrator(context) + try { + val data=JSONObject(file.readText()) + require(data.getInt("version")==1 && data.getString("identity")==identity && data.getInt("width")==width && data.getInt("height")==height) + val views=data.getJSONArray("views") + require(views.length() in 1..1000) + for (i in 0 until views.length()) { + val view=views.getJSONObject(i) + val points=CalibrationObservationData.parse(view) + restored.observations.add(BoardObservation( + MatOfPoint3f(*points.objects.map { Point3(it[0],it[1],it[2]) }.toTypedArray()), + MatOfPoint2f(*points.left.map { Point(it[0],it[1]) }.toTypedArray()), + MatOfPoint2f(*points.right.map { Point(it[0],it[1]) }.toTypedArray()),points.head)) + } + return restored + } catch (e: Exception) { + restored.close() + android.util.Log.w("StereoCalibration", "Saved captures could not be restored", e) + return null + } + } + internal fun stereoGeometry(objects: List, left: List, right: List, k1: Mat,d1: Mat,k2: Mat,d2: Mat, + size: Size,fish: Boolean,r: Mat,t: Mat) { + val e=Mat(); val f=Mat(); val identity=Mat.eye(3,3,CvType.CV_64F); val zero=Mat.zeros(5,1,CvType.CV_64F) + val corrected=mutableListOf() + fun images(input: List, k: Mat,d: Mat) = if (!fish) input else input.map { pixels -> + Mat().also { output -> corrected.add(output); Calib3d.fisheye_undistortPoints(pixels,output,k,d,identity,k) } + } + try { + // OpenCV 4.13 fisheye stereo fitting assumes equal corner counts in every view. + Calib3d.stereoCalibrate(objects,images(left,k1,d1),images(right,k2,d2),k1,if(fish)zero else d1,k2,if(fish)zero else d2, + size,r,t,e,f,Calib3d.CALIB_FIX_INTRINSIC) + } finally { (corrected+listOf(e,f,identity,zero)).forEach(Mat::release) } + } + fun matrix(q: SpatialRotation)=Mat(3,3,CvType.CV_64F).also { it.put(0,0,*q.matrix().map(Float::toDouble).toDoubleArray()) } + fun vector(p: SpatialVector)=Mat(3,1,CvType.CV_64F).also { it.put(0,0,p.x.toDouble(),p.y.toDouble(),p.z.toDouble()) } + fun pose(r: Mat,t: Mat)=SpatialPose(SpatialVector(t.get(0,0)[0].toFloat(),t.get(1,0)[0].toFloat(),t.get(2,0)[0].toFloat()), + SpatialRotation.fromBasis(column(r,0),column(r,1),column(r,2))) + private fun column(r: Mat,c: Int)=SpatialVector(r.get(0,c)[0].toFloat(),r.get(1,c)[0].toFloat(),r.get(2,c)[0].toFloat()) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibrationProfile.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibrationProfile.kt new file mode 100644 index 0000000000..f6728735a6 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoCalibrationProfile.kt @@ -0,0 +1,51 @@ +package com.droiddeck.launcher.glasses + +import org.json.JSONObject + +internal data class CalibrationMatrix(val rows: Int, val columns: Int, val values: DoubleArray) + +internal data class StereoCalibrationProfile( + val identity: String, val width: Int, val height: Int, val fisheye: Boolean, + val matrices: List, val cameraToHead: SpatialPose, val error: Double, + val verified: Boolean, val bundledBase: Boolean = false, +) { + companion object { + const val BASE_ASSET = "calibration/luma-ultra-640x480.json" + const val BASE_IDENTITY = "luma-ultra-base-v1" + + fun select(saved: String?, base: () -> String?, identity: String?, width: Int, height: Int): StereoCalibrationProfile? { + if (identity != null && saved != null) parse(saved, identity, width, height)?.let { return it } + return base()?.let { parse(it, identity ?: BASE_IDENTITY, width, height, bundledBase = true) } + } + + fun parse(text: String, identity: String, width: Int, height: Int, + bundledBase: Boolean = false): StereoCalibrationProfile? = runCatching { + val data = JSONObject(text) + require(data.getInt("version") == 1 && data.getInt("width") == width && data.getInt("height") == height) + if (bundledBase) { + require(data.getString("identity") == BASE_IDENTITY && data.getString("deviceModel") == "VITURE Luma Ultra") + require(data.getString("cameraPair") == "left0-right0" && width == 640 && height == 480) + } else require(data.getString("identity") == identity) + val fisheye = data.getBoolean("fisheye") + val matrices = listOf("k1", "d1", "k2", "d2", "r", "t").map { name -> + val matrix = data.getJSONObject(name) + val rows = matrix.getInt("rows"); val columns = matrix.getInt("cols") + val values = matrix.getJSONArray("data") + require(rows in 1..14 && columns in 1..14 && values.length() == rows * columns) + CalibrationMatrix(rows, columns, DoubleArray(values.length()) { values.getDouble(it).also { n -> require(n.isFinite()) } }) + } + require(listOf(0, 2, 4).all { matrices[it].rows == 3 && matrices[it].columns == 3 }) + require(matrices[5].rows == 3 && matrices[5].columns == 1) + require(listOf(1, 3).all { + val matrix = matrices[it] + (matrix.rows == 1 || matrix.columns == 1) && matrix.values.size in if (fisheye) listOf(4) else listOf(4, 5, 8, 12, 14) + }) + require(listOf(0, 2).all { matrices[it].values[0] > 0 && matrices[it].values[4] > 0 }) + val pose = data.getJSONArray("cameraToHead"); require(pose.length() == 7) + val cameraToHead = SpatialPose.fromSdk(FloatArray(7) { pose.getDouble(it).toFloat() }) ?: error("Invalid camera transform") + val error = data.getDouble("error"); require(error.isFinite() && error in 0.0..2.0) + StereoCalibrationProfile(identity, width, height, fisheye, matrices, cameraToHead, error, + verified = !bundledBase && data.getBoolean("verified"), bundledBase = bundledBase) + }.getOrNull() + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoFingerGestures.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoFingerGestures.kt new file mode 100644 index 0000000000..f43c0e134c --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoFingerGestures.kt @@ -0,0 +1,67 @@ +package com.droiddeck.launcher.glasses + +import kotlin.math.abs +import kotlin.math.min + +internal object StereoFingerGestures { + data class Result(val trigger: Float = 0f, val triggerValid: Boolean = false, + val grip: Boolean = false, val gripValid: Boolean = false) + + fun estimate(left: List?, right: List?, gripping: Boolean): Result { + val a = View.create(left) ?: return Result() + val b = View.create(right) ?: return Result() + val triggerA = a.pinch() + val triggerB = b.pinch() + val triggerValid = triggerA != null && triggerB != null && abs(triggerA-triggerB) <= 0.30f + val curls = listOf(9,13,17).map { base -> + val ca = a.curl(base) + val cb = b.curl(base) + if (ca != null && cb != null && abs(ca-cb) <= 0.45f) min(ca,cb) else null + } + val gripValid = curls.all { it != null } + val closed = curls.count { it != null && it >= (if (gripping) 0.40f else 0.65f) } + return Result(if (triggerValid) min(triggerA!!,triggerB!!) else 0f,triggerValid, + gripValid && closed >= (if (gripping) 2 else 3),gripValid) + } + + private class View(val points: List,val width: Float) { + private fun point(index: Int) = points[index].takeIf(SpatialVector::finite) + ?.let { SpatialVector(it.x,it.y) } + + fun pinch(): Float? { + val thumb = point(4) ?: return null + val index = point(8) ?: return null + val wrist = point(0) ?: return null + if ((thumb-wrist).length() > width*3.5f || (index-wrist).length() > width*3.5f) return null + return ((0.55f-(thumb-index).length()/width)/0.35f).coerceIn(0f,1f) + } + + fun curl(base: Int): Float? { + val wrist = point(0) ?: return null + val joints = (base..base+3).map { point(it) ?: return null } + val lengths = joints.zipWithNext { a,b -> (b-a).length() } + if (lengths.any { it < width*0.005f }) return null + val path = lengths.sum() + val reach = (joints[0]-wrist).length() + if (path !in width*0.15f..width*3f || reach < width*0.20f) return null + val shortness = ((1.7f-(joints[3]-wrist).length()/reach)/0.55f).coerceIn(0f,1f) + val bend = ((1f-(joints[3]-joints[0]).length()/path)/0.35f).coerceIn(0f,1f) + return min(shortness,bend) + } + + companion object { + fun create(points: List?): View? { + if (points?.size != 21) return null + if (listOf(0,5,9,13,17).any { !points[it].finite() }) return null + fun xy(index: Int) = SpatialVector(points[index].x,points[index].y) + val across = xy(5)-xy(17) + val along = xy(9)-xy(0) + val width = across.length() + val length = along.length() + if (!width.isFinite() || !length.isFinite() || width < 1e-3f || length < 1e-3f) return null + if (width/length !in 0.25f..3f || abs(across.cross(along).z)/(width*length) < 0.15f) return null + return View(points,width) + } + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoHandEngine.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoHandEngine.kt new file mode 100644 index 0000000000..0b086c7c4a --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoHandEngine.kt @@ -0,0 +1,650 @@ +package com.droiddeck.launcher.glasses + +import android.content.Context +import com.droiddeck.launcher.R +import android.graphics.Bitmap +import android.graphics.Canvas +import android.graphics.Color +import android.graphics.Paint +import com.google.mediapipe.framework.image.MPImage +import com.google.mediapipe.tasks.core.BaseOptions +import com.google.mediapipe.tasks.core.Delegate +import com.google.mediapipe.tasks.vision.core.RunningMode +import com.google.mediapipe.tasks.vision.handlandmarker.HandLandmarker +import org.opencv.android.OpenCVLoader +import org.opencv.android.Utils +import org.opencv.core.* +import org.opencv.imgproc.Imgproc +import org.opencv.imgcodecs.Imgcodecs +import org.json.JSONObject +import java.io.File +import java.nio.ByteBuffer +import java.security.MessageDigest +import java.util.concurrent.ConcurrentLinkedQueue + +internal data class HandTrackingDiagnostics(val message: String, val leftCameraHands: Int = 0, + val rightCameraHands: Int = 0, val matched: Int = 0, val reconstructed: Int = 0, val accepted: Int = 0, + val preprocessMs: Float = 0f, val inferenceMs: Float = 0f, + val triggerValid: Int = 0, val gripValid: Int = 0, + val leftRawHands: Int = 0, val rightRawHands: Int = 0, + val previousLeftRawHands: Int = -1, val previousRightRawHands: Int = -1, + val leftInferenceMs: Float = 0f, val rightInferenceMs: Float = 0f, + val inferenceHandLimit: Int = 2, + val observationTimeNs: Long = 0, val observationAgeMs: Float = -1f, + val left: HandObservationDiagnostic? = null, val right: HandObservationDiagnostic? = null, + val observations: HandTrackingMetricSnapshot? = null) { + fun json() = JSONObject().put("message",message).put("experimental",true).put("leftCameraHands",leftCameraHands) + .put("rightCameraHands",rightCameraHands).put("matched",matched).put("reconstructed",reconstructed).put("accepted",accepted) + .put("preprocessMs",preprocessMs.toDouble()).put("inferenceMs",inferenceMs.toDouble()) + .put("triggerValid",triggerValid).put("gripValid",gripValid) + .put("leftRawHands",leftRawHands).put("rightRawHands",rightRawHands) + .put("previousLeftRawHands",previousLeftRawHands).put("previousRightRawHands",previousRightRawHands) + .put("leftInferenceMs",leftInferenceMs.toDouble()).put("rightInferenceMs",rightInferenceMs.toDouble()) + .put("inferenceHandLimit",inferenceHandLimit) + .put("observationTimeNs",observationTimeNs).put("observationAgeMs",observationAgeMs.toDouble()) + .put("left",left?.json()).put("right",right?.json()).put("observations",observations?.json()) +} + +private fun HandObservationDiagnostic.json() = JSONObject().put("outcome",outcome.name.lowercase()) + .put("positionSource",positionSource) + .put("reconstructedPalmLandmarks",org.json.JSONArray(reconstructedPalmLandmarks)) + .put("accepted",accepted).put("triggerEstimate",triggerEstimate.toDouble()) + .put("triggerGeometryValid",triggerGeometryValid).put("triggerValid",triggerValid) + .put("gripEstimate",gripEstimate).put("gripGeometryValid",gripGeometryValid).put("gripValid",gripValid) + +private fun HandSideMetrics.json() = JSONObject().put("observations",observations).put("accepted",accepted) + .put("triggerValid",triggerValid).put("gripValid",gripValid) + .put("triggerAboveClickThreshold",triggerAboveClickThreshold).put("triggerReleased",triggerReleased) + .put("gripPressed",gripPressed).put("trackingLosses",trackingLosses) + .put("triggerLosses",triggerLosses).put("gripLosses",gripLosses) + .put("maximumConsecutiveRejected",maximumConsecutiveRejected) + .put("outcomes",JSONObject().also { json -> outcomes.forEach { (outcome,count) -> json.put(outcome.name.lowercase(),count) } }) + +private fun HandTrackingMetricSnapshot.json() = JSONObject().put("processedPairs",processedPairs).put("inferencePairs",inferencePairs) + .put("scope","Processed camera pairs in this tracking connection, including absent hands and setup; not detection accuracy") + .put("left",left.json()).put("right",right.json()) + +internal class StereoHandEngine(private val context: Context, private val token: Long, + private val generation: Long, private val identity: String?) : AutoCloseable { + @Volatile private var running=true + @Volatile private var enabled=false + @Volatile private var debug=false + @Volatile var preview: Bitmap? = null; private set + @Volatile var message=context.getString(R.string.spatial_wait_cameras); private set + @Volatile var calibrationProgress = SpatialCalibrationProgress(); private set + @Volatile var handStatus = HandTrackingDiagnostics(context.getString(R.string.spatial_wait_hands)); private set + val hasStableIdentity get() = identity != null + private val commands=ConcurrentLinkedQueue<() -> Unit>() + private var calibrator: StereoCalibrator?=null + private var calibrationFrame = 0L + private var calibration: StereoCalibration?=null + val calibrationSource get() = calibration?.source ?: "none" + val calibrationVerified get() = calibration?.verified == true + val lensCorrection get() = calibration?.let { if(it.fisheye) "fisheye-points-only" else "pinhole-points-only" } ?: "none" + private var capture=false + private var record=false + private var verify: Float?=null + private var validationRequestedAt=0L + @Volatile var gpu=false; private set + @Volatile var model=HandModel.DEFAULT; private set + @Volatile var halfRateInput=true; private set + @Volatile var adaptiveInput=true; private set + @Volatile var scheduledTracking=true; private set + @Volatile var inputRatePermille=500; private set + @Volatile var cpuParallel=true; private set + @Volatile var benchmark: JSONObject?=null; private set + @Volatile var inferenceBackend: String? = null; private set + private var detectors: DetectorBank?=null + private var fastDetectors: DetectorBank?=null + private var rightWorker: StereoInferenceRunner?=null + private val inferenceSchedule=HandInferenceSchedule() + private val processingRate=HandProcessingRate() + private val handMetrics=HandTrackingMetrics() + private val gestures=Array(2) { HandGestures(rightHand=it==1) } + private val joyConPositions=Array(2) { JoyConWristPosition() } + private var joyConFlow: StereoJoyConFlow? = null + private val profile: File get() { + val hash=MessageDigest.getInstance("SHA-256").digest((identity ?: "session:$generation").toByteArray()).joinToString("") { "%02x".format(it) } + return File(context.filesDir,"spatial/calibration-$hash.json") + } + private val captures: File get() = File(profile.parentFile,profile.nameWithoutExtension+"-captures.json") + private fun saveCaptures() { + try { calibrator?.save(captures,identity ?: "session:$generation",width,height) } + catch (e: Exception) { android.util.Log.w("StereoCalibration", "Could not save captured views", e) } + } + fun setEnabled(on: Boolean) { enabled=on } + fun diagnostics(on: Boolean) { debug=on } + fun setGpu(on: Boolean) { commands.add { clearHands();closeDetectors();gpu=on } } + fun setModel(lite: Boolean) { commands.add { + clearHands();closeDetectors();model=if(lite) HandModel.LITE else HandModel.FULL + } } + fun setHalfRate(on: Boolean) { commands.add { adaptiveInput=false;halfRateInput=on;processingRate.reset() } } + fun setAdaptiveInput(on: Boolean) { commands.add { adaptiveInput=on;processingRate.reset() } } + fun setScheduledTracking(on: Boolean) { commands.add { clearHands();closeDetectors();scheduledTracking=on } } + fun setCpuParallel(on: Boolean) { commands.add { clearHands();closeDetectors();cpuParallel=on } } + fun benchmarkSavedCapture(id: String) { + require(id.matches(Regex("[0-9]{1,20}"))) + benchmark=JSONObject().put("state","pending").put("capture",id) + commands.add { + try { benchmark=benchmarkCapture(id) } + catch(e: Exception) { benchmark=JSONObject().put("state","failed").put("error",e.message) } + } + } + fun startCalibration() { debug=true; commands.add { + check(width > 0 && height > 0) { context.getString(R.string.spatial_wait_previews) } + calibrator?.close();calibrator=StereoCalibrator(context) + calibrationFrame = SpatialTracking.session.trackingFrameGeneration + calibrationProgress = SpatialCalibrationProgress(collecting = true) + saveCaptures() + message=context.getString(R.string.spatial_collect_instructions) + } } + fun captureCalibration() { commands.add { + check(calibrationProgress.collecting && calibrationFrame==SpatialTracking.session.trackingFrameGeneration) { + context.getString(R.string.spatial_saved_views_hint) + } + capture=true + calibrationProgress = calibrationProgress.copy(capturing = true, captureMessage = context.getString(R.string.spatial_capture_pending)) + } } + fun recordDiagnostic() { commands.add { record=true } } + fun validateCalibration(distance: Float) { commands.add { + require(distance.isFinite() && distance in 0.15f..1.5f) + verify=distance;validationRequestedAt=System.nanoTime() + calibrationProgress=calibrationProgress.copy(validating=true, + validationMessage=context.getString(R.string.spatial_validation_pending)) + } } + private var width=0; private var height=0 + private val imageBuffer=HandImageBuffer() + private val rightImageBuffer=HandImageBuffer() + private val worker=Thread({ loop() },"viture-stereo-hands").apply { isDaemon=true; start() } + fun solveCalibration() { commands.add { + val c=calibrator ?: error(context.getString(R.string.spatial_start_first)) + saveCaptures() + calibrationProgress = calibrationProgress.copy(solving = true, validationMessage = null) + try { + val fitted=c.solve(identity ?: "session:$generation",width,height) + clearHands();closeDetectors() + calibration?.close();calibration=fitted + calibrationProgress = calibrationProgress.copy(fitted = true) + if(identity!=null) fitted.save(profile) + message=context.getString(R.string.spatial_fit_ready, fitted.error) + } finally { calibrationProgress = calibrationProgress.copy(solving = false) } + } } + private fun detector(selected: HandModel=model, useGpu: Boolean=gpu, maxHands: Int=2): HandLandmarker { + val bytes=context.assets.open(selected.asset).use { it.readBytes() } + val hash=MessageDigest.getInstance("SHA-256").digest(bytes).joinToString("") { "%02x".format(it) } + check(hash==selected.sha256) { context.getString(R.string.spatial_model_checksum_error) } + return HandLandmarker.createFromOptions(context,HandLandmarker.HandLandmarkerOptions.builder() + .setBaseOptions(BaseOptions.builder().setModelAssetPath(selected.asset) + .setDelegate(if(useGpu) Delegate.GPU else Delegate.CPU).build()) + .setRunningMode(RunningMode.VIDEO).setNumHands(maxHands).setMinHandDetectionConfidence(0.6f) + .setMinHandPresenceConfidence(0.6f).setMinTrackingConfidence(0.6f).build()) + } + private data class Detection(val side: Int,val points: List) + private data class Detections(val hands: List,val rawCount: Int,val inferenceMs: Float) + private class DetectorBank(val left: HandLandmarker, val right: HandLandmarker, val maxHands: Int) { + var previousLeftRaw=-1 + var previousRightRaw=-1 + } + private fun createBank(selected: HandModel, useGpu: Boolean, maxHands: Int, + worker: StereoInferenceRunner?): DetectorBank { + val left=detector(selected,useGpu,maxHands) + try { + val right=worker?.onRight { detector(selected,useGpu,maxHands) } ?: detector(selected,useGpu,maxHands) + return DetectorBank(left,right,maxHands) + } catch(e: Throwable) { left.close();throw e } + } + private fun closeBank(bank: DetectorBank?, worker: StereoInferenceRunner?) { + if(bank==null) return + try { bank.left.close() } finally { + if(worker!=null) worker.onRight { bank.right.close() } else bank.right.close() + } + } + private fun imagePoints(detection: Detection?) = detection?.points?.map { + SpatialVector(it.x.toFloat(),it.y.toFloat(),0f) + } + private fun detect(detector: HandLandmarker, bitmap: Bitmap, stamp: Long, buffer: HandImageBuffer, + wristOnly: Boolean): Detections = + detect(detector,stamp,wristOnly) { buffer.image(bitmap) } + private fun detect(detector: HandLandmarker, stamp: Long, wristOnly: Boolean, + prepareImage: () -> MPImage): Detections { + val image=prepareImage() + try { + val start=System.nanoTime() + val result=detector.detectForVideo(image,stamp) + val elapsed=(System.nanoTime()-start)/1e6f + val hands=result.landmarks().mapIndexedNotNull { i, hand -> + val category=result.handedness()[i].firstOrNull() ?: return@mapIndexedNotNull null + if(category.score()<0.6f) return@mapIndexedNotNull null + val points=if(wristOnly) hand.take(1) else hand + Detection(if(category.categoryName()=="Left") 0 else 1,points.map { Point(it.x()*image.width.toDouble(),it.y()*image.height.toDouble()) }) + } + return Detections(hands,result.landmarks().size,elapsed) + } finally { image.close() } + } + private fun closeDetectors() { + inferenceBackend=null + inferenceSchedule.reset();processingRate.reset() + val search=detectors;val fast=fastDetectors;val worker=rightWorker + detectors=null;fastDetectors=null;rightWorker=null + try { closeBank(search,worker) } finally { + try { closeBank(fast,worker) } finally { worker?.close() } + } + } + private fun detectPair(left: HandLandmarker, right: HandLandmarker, leftImage: Bitmap, + rightImage: Bitmap, stamp: Long, worker: StereoInferenceRunner?, wristOnly: Boolean): Pair { + val l={ detect(left,leftImage,stamp,imageBuffer,wristOnly) };val r={ detect(right,rightImage,stamp,rightImageBuffer,wristOnly) } + return worker?.pair(l,r) ?: (l() to r()) + } + private fun detectRawPair(left: HandLandmarker, right: HandLandmarker, leftGray: ByteArray, + rightGray: ByteArray, stamp: Long, worker: StereoInferenceRunner?, wristOnly: Boolean): Pair { + val l={ detect(left,stamp,wristOnly) { imageBuffer.image(leftGray,width,height) } } + val r={ detect(right,stamp,wristOnly) { rightImageBuffer.image(rightGray,width,height) } } + return worker?.pair(l,r) ?: (l() to r()) + } + private fun benchmarkCapture(id: String): JSONObject { + val folder=File(context.filesDir,"spatial/captures/$id") + val c=calibration ?: error("Load the saved calibration before benchmarking") + val wristOnly=SpatialTracking.joyConsEnabled + val gray=ArrayList();val images=ArrayList();val rows=org.json.JSONArray() + clearHands();closeDetectors() + try { + for(name in listOf("left","right")) { + val source=Imgcodecs.imread(File(folder,"$name.png").path,Imgcodecs.IMREAD_GRAYSCALE) + gray.add(source) + check(source.cols()==width && source.rows()==height) { "Saved pair has incompatible dimensions" } + val rgba=Mat() + try { + Imgproc.cvtColor(source,rgba,Imgproc.COLOR_GRAY2RGBA) + val bitmap=Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888) + images.add(bitmap);Utils.matToBitmap(rgba,bitmap) + } finally { rgba.release() } + } + for((selected,parallel,scheduled) in listOf(Triple(HandModel.FULL,true,false),Triple(HandModel.FULL,true,true), + Triple(HandModel.LITE,true,true),Triple(HandModel.FULL,true,false))) { + var search: DetectorBank?=null;var fast: DetectorBank?=null + val schedule=HandInferenceSchedule() + val worker=if(parallel) StereoInferenceRunner() else null + val times=ArrayList();val samples=org.json.JSONArray() + try { + search=createBank(selected,false,2,worker) + if(scheduled) fast=createBank(selected,false,1,worker) + repeat(24) { frame -> + check(running) { "Tracking stopped during benchmark" } + val start=System.nanoTime();val stamp=1000L+frame*80L + val bank=if(scheduled && schedule.select(stamp)==1) fast!! else search + val (leftResult,rightResult)=detectPair(bank.left,bank.right,images[0],images[1],stamp,worker,wristOnly) + val l=leftResult.hands;val r=rightResult.hands + if(scheduled) schedule.observe(stamp,l.map { it.side },r.map { it.side },leftResult.rawCount,rightResult.rawCount) + val ms=(System.nanoTime()-start)/1e6 + val hands=org.json.JSONArray() + val joyCons=org.json.JSONArray() + val wrists=org.json.JSONArray() + for(side in 0..1) { + val a=l.singleOrNull { it.side==side };val b=r.singleOrNull { it.side==side } + val points=if(a!=null && b!=null) c.triangulateLandmarksRaw(a.points,b.points) else null + points?.get(0)?.takeIf { it.finite() }?.let { wrist -> + wrists.put(JSONObject().put("side",side).put("position",org.json.JSONArray(wrist.array().toList()))) + } + val hand=if(wristOnly) null else points?.let { HandGestures(rightHand=side==1).estimate(it,SpatialPose(),stamp*1_000_000,imagePoints(a),imagePoints(b)) } + val joyCon=if(wristOnly) points?.let { JoyConWristPosition().estimate(it,SpatialPose(),stamp*1_000_000) } else null + if(joyCon!=null) joyCons.put(JSONObject().put("side",side) + .put("position",org.json.JSONArray(joyCon.pose.position.array().toList()))) + if(hand!=null) hands.put(JSONObject().put("side",side).put("flags",hand.flags()) + .put("position",org.json.JSONArray(hand.pose.position.array().toList())) + .put("trigger",hand.trigger.toDouble()).put("grip",hand.grip)) + } + if(frame>=4) { + times.add(ms);samples.put(JSONObject().put("left",l.size).put("right",r.size).put("hands",hands) + .put("joyCons",joyCons).put("wrists",wrists) + .put("inferenceHandLimit",bank.maxHands) + .put("leftRawHands",leftResult.rawCount).put("rightRawHands",rightResult.rawCount) + .put("leftInferenceMs",leftResult.inferenceMs.toDouble()).put("rightInferenceMs",rightResult.inferenceMs.toDouble())) + } + } + } finally { + try { closeBank(search,worker) } finally { + try { closeBank(fast,worker) } finally { worker?.close() } + } + } + val sorted=times.sorted() + rows.put(JSONObject().put("model",selected.name).put("parallel",parallel).put("medianMs",(sorted[9]+sorted[10])/2) + .put("scheduled",scheduled) + .put("p95Ms",sorted[18]).put("samples",samples)) + } + return JSONObject().put("state","completed").put("capture",id).put("backend","CPU") + .put("wristOnly",wristOnly).put("imagePreprocessing",HandImageBuffer.PREPROCESSING) + .put("lensCorrection",lensCorrection) + .put("scope","Saved stereo pair replay; not live tracking or external latency").put("results",rows) + } finally { gray.forEach { it.release() };images.forEach { it.recycle() };clearHands() } + } + private fun clearHands() { + gestures.forEach { it.reset() } + joyConPositions.forEach { it.reset() } + joyConFlow?.reset() + inferenceSchedule.reset();processingRate.reset() + SpatialTracking.session.setHands(generation,SpatialHand(),SpatialHand()) + } + private fun loop() { + try { check(OpenCVLoader.initLocal()) } catch(e: Throwable) { message=context.getString(R.string.spatial_opencv_error, e.message.orEmpty());return } + var grayL=Mat();var grayR=Mat();val rgba=Mat() + var bmpL: Bitmap?=null;var bmpR: Bitmap?=null + var leftGray=ByteArray(0);var rightGray=ByteArray(0) + val left=ByteBuffer.allocateDirect(2048*2048);val right=ByteBuffer.allocateDirect(2048*2048) + val metadata=DoubleArray(9);val headData=FloatArray(7) + var lastSeq=0L;var dropped=0L;var frames=0L;var previewTime=0L + val clock=CameraClock() + var lastSource=0L;var lastStamp=0L;var captureOn=false;var captureRate=1000;var lastInputSeq=0L + var rate=0f + try { + check(OpenCVLoader.initLocal()) { context.getString(R.string.spatial_opencv_load_error) } + joyConFlow=StereoJoyConFlow() + while(running) { + while(true) { + val command=commands.poll() ?: break + try { command() } catch(e: Exception) { message=e.message ?: e.toString() } + } + if (verify!=null && System.nanoTime()-validationRequestedAt>2_000_000_000L) { + verify=null + calibrationProgress=calibrationProgress.copy(validating=false, + validationMessage=context.getString(R.string.spatial_no_camera_frame)) + } + val want=enabled || debug + val copyPermille=if(enabled && !calibrationProgress.collecting && !capture && verify==null && !record) + if(adaptiveInput && !gpu) processingRate.permille else if(halfRateInput) 500 else 1000 + else 1000 + inputRatePermille=copyPermille + if(want!=captureOn || copyPermille!=captureRate) { + VitureSdk.nativeCapture(token,want,copyPermille);captureOn=want;captureRate=copyPermille + if(!want) clearHands() + } + if(!want) { Thread.sleep(20);continue } + val seq=VitureSdk.nativeStereo(token,left,right,metadata,headData,!enabled || capture) + if(seq<=0) { Thread.sleep(5);continue } + val sequenceDelta=if(lastSeq>0) (seq-lastSeq).coerceAtLeast(1) else 1 + if(lastSeq>0) dropped+=(sequenceDelta-1) + lastSeq=seq;frames++ + val start=System.nanoTime();val source=(metadata[2]*1e9).toLong();val receipt=metadata[3].toLong() + val inputSequence=metadata[7].toLong() + if(source<=lastSource) { clearHands();message=context.getString(R.string.spatial_clock_reset);closeDetectors();lastStamp=0 } + if(lastSource>0 && source>lastSource) { + val hz=1e9f*(inputSequence-lastInputSeq).coerceAtLeast(1)/(source-lastSource) + rate=if(rate==0f)hz else rate*.9f+hz*.1f + } + lastSource=source;lastInputSeq=inputSequence + val time=clock.map(source,receipt) ?: 0L + val trackingFrame = SpatialTracking.session.trackingFrameGeneration + if (calibrator != null && calibrationProgress.collecting && calibrationFrame != trackingFrame) { + capture=false + message=context.getString(R.string.spatial_frame_changed) + calibrationProgress = calibrationProgress.copy(collecting = false, capturing = false, captureMessage = message) + } + // The callback pose's basis is undocumented; use canonical GL pose history. + val observation=HandObservation(time,generation,trackingFrame) + var captureHead=observation.headPose(SpatialTracking.session,metadata[6]>0) + val w=metadata[0].toInt();val h=metadata[1].toInt() + if(w!=width || h!=height) { + clearHands();closeDetectors() + width=w;height=h;leftGray=ByteArray(w*h);rightGray=ByteArray(w*h) + grayL.release();grayR.release();grayL=Mat(h,w,CvType.CV_8UC1);grayR=Mat(h,w,CvType.CV_8UC1) + bmpL?.recycle();bmpR?.recycle();bmpL=null;bmpR=null + calibration?.close() + val selected=StereoCalibrationProfile.select( + if(identity!=null) runCatching { profile.readText() }.getOrNull() else null, + { runCatching { context.assets.open(StereoCalibrationProfile.BASE_ASSET).bufferedReader().use { it.readText() } }.getOrNull() }, + identity,w,h) + calibration=selected?.let(StereoCalibration::fromProfile) + calibrator?.close();calibrator=null + calibrationProgress = SpatialCalibrationProgress(fitted = calibration != null) + message=context.getString(R.string.spatial_stereo_loaded, w, h, when { + calibration?.verified==true -> context.getString(R.string.spatial_device_loaded) + calibration?.bundledBase==true -> context.getString(R.string.spatial_base_loaded) + else -> context.getString(R.string.spatial_calibration_needed) + }) + if (identity!=null) calibrator=StereoCalibrator.load(context,captures,identity,w,h) + calibrator?.let { + calibrationFrame=-1 + val restored=context.getString(R.string.spatial_restored, it.observations.size) + calibrationProgress=calibrationProgress.copy(views=it.observations.size,captureMessage=restored) + message=restored + } + } + left.position(0);left.get(leftGray) + right.position(0);right.get(rightGray) + val joyConMode=SpatialTracking.joyConsEnabled + val drawPreview=debug && start-previewTime>150_000_000L + if(capture || verify!=null || record || drawPreview || joyConMode) { + grayL.put(0,0,leftGray);grayR.put(0,0,rightGray) + } + if(capture) { + capture=false + val observation=captureHead?.let { calibrator?.detect(grayL,grayR,it) } + val currentTracking = SpatialTracking.session.isCurrentTrackingFrame(generation, trackingFrame) + if(observation!=null && currentTracking) { + calibrator!!.observations.add(observation) + calibrationProgress = calibrationProgress.copy(views = calibrator!!.observations.size) + saveCaptures() + message=context.getString(R.string.spatial_captured, calibrator!!.observations.size) + } else { + observation?.let { listOf(it.objects,it.left,it.right).forEach(Mat::release) } + message = when { + calibrator == null -> context.getString(R.string.spatial_tap_start) + SpatialTracking.session.recenterPending -> context.getString(R.string.spatial_capture_recenter_pending) + SpatialTracking.session.needsRecenter -> context.getString(R.string.spatial_capture_recenter) + captureHead == null || !currentTracking -> context.getString(R.string.spatial_capture_unsynchronized) + else -> context.getString(R.string.spatial_capture_corners, calibrator?.commonCorners ?: 0) + } + } + calibrationProgress = calibrationProgress.copy(capturing = false, captureMessage = message) + } + val c=calibration + val distance=verify + if(distance!=null) { + verify=null + var temporary: StereoCalibrator?=null + var observed: BoardObservation?=null + try { + check(c!=null) { context.getString(R.string.spatial_align_first) } + temporary=StereoCalibrator(context) + observed=temporary.detect(grayL,grayR,SpatialPose()) + val points=observed?.let { c.triangulateRaw(it.left,it.right) } + val result=CalibrationDistanceCheck.evaluate(context,distance,temporary.commonCorners,points) + if(result.accepted) { + c.verified=true;if(identity!=null)c.save(profile) + calibrationProgress=calibrationProgress.copy(validationMessage=result.message+ + if(identity==null) " " + context.getString(R.string.spatial_validation_session) else " " + context.getString(R.string.spatial_validation_saved)) + } else calibrationProgress=calibrationProgress.copy(validationMessage=result.message) + } catch (e: Exception) { + android.util.Log.w("StereoCalibration","Distance validation failed",e) + calibrationProgress=calibrationProgress.copy(validationMessage=context.getString(R.string.spatial_validation_error, e.message?.substringBefore('\n') ?: context.getString(R.string.spatial_processing_failed))) + } finally { + calibrationProgress=calibrationProgress.copy(validating=false) + observed?.let { listOf(it.objects,it.left,it.right).forEach(Mat::release) };temporary?.close() + } + } + var dl=emptyList();var dr=emptyList() + var trackingHealthy=false + var inferred=false + val sideDiagnostics=Array(2) { HandObservationDiagnostic(HandObservationOutcome.NO_MATCHING_DETECTION) } + val nextStatus: HandTrackingDiagnostics + if(enabled && c?.readyForTracking==true && time>0 && SpatialTracking.session.isCurrentTrackingFrame(generation, trackingFrame) && System.nanoTime()-time in 0..HandObservation.MAX_AGE_NS) { + val preprocessMs=(System.nanoTime()-start)/1e6f + if(detectors==null) { + try { + rightWorker=if(cpuParallel && !gpu) StereoInferenceRunner() else null + detectors=createBank(model,gpu,2,rightWorker) + if(scheduledTracking && !gpu) fastDetectors=createBank(model,false,1,rightWorker) + inferenceBackend=if(gpu) "GPU" else "CPU" + } + catch(e: Exception) { + closeDetectors() + enabled=false;clearHands();message=context.getString(R.string.spatial_inference_error, e.message.orEmpty()) + val unavailable=HandObservationDiagnostic(HandObservationOutcome.INFERENCE_UNAVAILABLE) + handMetrics.observe(seq,false,unavailable,unavailable) + handStatus=HandTrackingDiagnostics(message,observationTimeNs=time, + observationAgeMs=(System.nanoTime()-time)/1e6f,left=unavailable,right=unavailable,observations=handMetrics.snapshot()) + continue + } + } + val stamp=maxOf(time/1_000_000,lastStamp+1);lastStamp=stamp + val inferenceStart=System.nanoTime() + val scheduled=scheduledTracking && !gpu + val bank=if(scheduled && inferenceSchedule.select(stamp)==1) fastDetectors!! else detectors!! + val pair=detectRawPair(bank.left,bank.right,leftGray,rightGray,stamp,rightWorker,joyConMode) + inferred=true + dl=pair.first.hands;dr=pair.second.hands + if(scheduled) inferenceSchedule.observe(stamp,dl.map { it.side },dr.map { it.side },pair.first.rawCount,pair.second.rawCount) + val inferenceMs=(System.nanoTime()-inferenceStart)/1e6f + // VIO callbacks can arrive during inference; verify this exact camera stamp before publishing. + captureHead=observation.headPose(SpatialTracking.session, + metadata[6]>0 || VitureSdk.nativeCameraSynchronized(token,metadata[2])) + val hands=Array(2) { SpatialHand() } + if (joyConMode) joyConFlow?.begin(grayL,grayR,time) else joyConFlow?.reset() + var matched=0;var reconstructed=0 + for(side in 0..1) { + val leftCandidates=dl.filter { it.side==side };val rightCandidates=dr.filter { it.side==side } + val l=leftCandidates.singleOrNull();val r=rightCandidates.singleOrNull() + val detectedPoints=if(l!=null && r!=null) { + matched++ + c.triangulateLandmarksRaw(l.points,r.points) + } else null + var points=detectedPoints + if(points?.any { it != null }==true) reconstructed++ + var hand=points?.let { p -> captureHead?.let { head -> + if (joyConMode) joyConPositions[side].estimate(p,head*c.cameraToHead,time) + else gestures[side].estimate(p,head*c.cameraToHead,time,imagePoints(l),imagePoints(r)) + } } + var positionSource=if(hand!=null) "landmarks" else "none" + if (joyConMode && captureHead!=null) { + if (hand!=null && l!=null && r!=null && detectedPoints!=null) + joyConFlow?.seed(side,l.points.first(),r.points.first(),time) + else if (leftCandidates.size<=1 && rightCandidates.size<=1) { + joyConFlow?.points(side)?.let { tracked -> + val flowed=c.triangulateLandmarksRaw(tracked.left,tracked.right) + val position=flowed?.let { joyConPositions[side].estimate(it,captureHead!!*c.cameraToHead,time) } + if(position!=null) { hand=position;points=flowed;positionSource="stereo_flow" } + } + } + } + val outcome=when { + hand!=null -> HandObservationOutcome.ACCEPTED + leftCandidates.size>1 || rightCandidates.size>1 -> HandObservationOutcome.AMBIGUOUS_HANDEDNESS + l==null && r==null -> HandObservationOutcome.NO_MATCHING_DETECTION + l==null || r==null -> HandObservationOutcome.ONE_CAMERA_ONLY + points?.any { it != null }!=true -> HandObservationOutcome.STEREO_REJECTED + captureHead==null -> HandObservationOutcome.CAMERA_NOT_SYNCHRONIZED + else -> if (joyConMode) joyConPositions[side].lastOutcome else gestures[side].lastOutcome + } + sideDiagnostics[side]=HandObservationDiagnostic(outcome, + listOf(0,5,9,13,17).filter { points?.getOrNull(it)?.finite()==true }, + hand?.trigger ?: 0f,hand?.triggerValid ?: false,hand?.grip ?: false,hand?.gripValid ?: false,positionSource) + if (hand!=null) hands[side]=hand + else if (joyConMode) gestures[side].reset() + else gestures[side].resetAfterRejection(outcome) + } + if (joyConMode) joyConFlow?.end(grayL,grayR,time) + val current=SpatialTracking.session.isCurrentTrackingFrame(generation, trackingFrame) && + joyConMode==SpatialTracking.joyConsEnabled + val fresh=System.nanoTime()-time in 0..HandObservation.MAX_AGE_NS + if (current && fresh) + SpatialTracking.session.setHands(generation,hands[0],hands[1]) + else { + clearHands() + for(side in 0..1) sideDiagnostics[side]=sideDiagnostics[side].copy(outcome= + if(!current) HandObservationOutcome.HEAD_TRACKING_INVALID else HandObservationOutcome.STALE_OBSERVATION) + } + val accepted=if(current && fresh) hands.count { it.valid } else 0 + trackingHealthy=accepted>0 + nextStatus=HandTrackingDiagnostics(when { + !current -> context.getString(R.string.spatial_hand_head_changed) + !fresh -> context.getString(R.string.spatial_hand_timeout, HandObservation.MAX_AGE_NS / 1_000_000) + captureHead==null -> context.getString(R.string.spatial_hand_wait_sync) + accepted>0 && joyConMode -> context.getString(R.string.spatial_wrists_tracked, accepted) + accepted>0 -> context.getString(R.string.spatial_palms_tracked, accepted, hands.count { it.valid && it.triggerValid }, hands.count { it.valid && it.gripValid }) + dl.isEmpty() && dr.isEmpty() && joyConMode -> context.getString(R.string.spatial_no_wrists) + dl.isEmpty() && dr.isEmpty() -> context.getString(R.string.spatial_no_hands) + (dl.isEmpty() || dr.isEmpty()) && joyConMode -> context.getString(R.string.spatial_one_camera_wrists) + dl.isEmpty() || dr.isEmpty() -> context.getString(R.string.spatial_one_camera_hands) + matched==0 -> context.getString(R.string.spatial_ambiguous_hands) + reconstructed==0 -> context.getString(R.string.spatial_inconsistent_depth) + joyConMode -> context.getString(R.string.spatial_rejected_wrist) + else -> context.getString(R.string.spatial_inconsistent_palm) + },dl.size,dr.size,matched,reconstructed,accepted,preprocessMs,inferenceMs, + if(current && fresh) hands.count { it.valid && it.triggerValid } else 0, + if(current && fresh) hands.count { it.valid && it.gripValid } else 0, + pair.first.rawCount,pair.second.rawCount,bank.previousLeftRaw,bank.previousRightRaw, + pair.first.inferenceMs,pair.second.inferenceMs,bank.maxHands) + bank.previousLeftRaw=pair.first.rawCount;bank.previousRightRaw=pair.second.rawCount + } else { + clearHands() + val outcome=when { + !enabled -> HandObservationOutcome.DISABLED + c?.readyForTracking!=true -> HandObservationOutcome.CALIBRATION_REQUIRED + time<=0 -> HandObservationOutcome.CLOCK_NOT_READY + !SpatialTracking.session.isCurrentTrackingFrame(generation,trackingFrame) -> HandObservationOutcome.HEAD_TRACKING_INVALID + else -> HandObservationOutcome.STALE_OBSERVATION + } + for(side in 0..1) sideDiagnostics[side]=HandObservationDiagnostic(outcome) + nextStatus=HandTrackingDiagnostics(when { + !enabled -> context.getString(R.string.spatial_hands_off) + c?.readyForTracking!=true -> context.getString(R.string.spatial_hands_need_calibration) + captureHead==null -> context.getString(R.string.spatial_hand_wait_sync) + !SpatialTracking.session.isCurrentTrackingFrame(generation,trackingFrame) -> context.getString(R.string.spatial_hands_wait_stable) + else -> context.getString(R.string.spatial_old_frame) + }) + } + handMetrics.observe(seq,inferred,sideDiagnostics[0],sideDiagnostics[1]) + handStatus=nextStatus.copy(observationTimeNs=time, + observationAgeMs=if(time>0) (System.nanoTime()-time)/1e6f else -1f, + left=sideDiagnostics[0],right=sideDiagnostics[1],observations=handMetrics.snapshot()) + if(drawPreview) { + previewTime=start + if(bmpL==null) bmpL=Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888) + if(bmpR==null) bmpR=Bitmap.createBitmap(w,h,Bitmap.Config.ARGB_8888) + Imgproc.cvtColor(grayL,rgba,Imgproc.COLOR_GRAY2RGBA);Utils.matToBitmap(rgba,bmpL) + Imgproc.cvtColor(grayR,rgba,Imgproc.COLOR_GRAY2RGBA);Utils.matToBitmap(rgba,bmpR) + val combined=Bitmap.createBitmap(w*2,h,Bitmap.Config.ARGB_8888);val canvas=Canvas(combined) + canvas.drawBitmap(bmpL!!,0f,0f,null);canvas.drawBitmap(bmpR!!,w.toFloat(),0f,null) + val paint=Paint().apply { color=Color.GREEN;strokeWidth=3f } + for((index,detections) in listOf(dl,dr).withIndex()) for(d in detections) for(p in d.points) + canvas.drawCircle(p.x.toFloat()+index*w,p.y.toFloat(),3f,paint) + preview=combined + } + if(record) { + record=false + val folder=File(context.filesDir,"spatial/captures/$receipt").apply { mkdirs() } + Imgcodecs.imwrite(File(folder,"left.png").path,grayL);Imgcodecs.imwrite(File(folder,"right.png").path,grayR) + File(folder,"frame.json").writeText(JSONObject().put("sourceSeconds",metadata[2]).put("receiptNs",receipt) + .put("connection",generation).put("width",w).put("height",h).put("pairedPose",captureHead!=null).toString()) + message=context.getString(R.string.spatial_capture_saved, folder.path) + } + if(running && generation==SpatialTracking.session.generation) { + val finished=System.nanoTime() + if(adaptiveInput && !gpu) processingRate.observe(finished-start,if(time>0) finished-time else -1,trackingHealthy) + SpatialTracking.statistics(c?.readyForTracking==true,frames,dropped,(finished-start)/1e6f, + if(time>0)(finished-time)/1e6f else -1f,rate,captureHead!=null, + when(copyPermille) { 500 -> 2;1000 -> 1;else -> 0 },metadata[8].toLong(),copyPermille) + SpatialTracking.publish(System.nanoTime()) + } + } + } catch(e: InterruptedException) { /* Shutdown interrupts the idle wait. */ } + catch(e: Throwable) { + message=context.getString(R.string.spatial_hand_error, e.message.orEmpty()) + val unavailable=HandObservationDiagnostic(HandObservationOutcome.INFERENCE_UNAVAILABLE) + handStatus=HandTrackingDiagnostics(message,left=unavailable,right=unavailable,observations=handMetrics.snapshot()) + calibrationProgress = calibrationProgress.copy(capturing = false, captureMessage = message, + validating = false, validationMessage = if(calibrationProgress.validating) message else calibrationProgress.validationMessage) + clearHands() + } + finally { + VitureSdk.nativeCapture(token,false,1000) + joyConFlow?.close();joyConFlow=null + closeDetectors() + calibration?.close();calibrator?.close() + listOf(grayL,grayR,rgba).forEach(Mat::release);bmpL?.recycle();bmpR?.recycle() + } + } + override fun close() { + running=false;worker.interrupt() + if(Thread.currentThread()!==worker) worker.join(2000) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoInferenceRunner.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoInferenceRunner.kt new file mode 100644 index 0000000000..351fe332e5 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoInferenceRunner.kt @@ -0,0 +1,38 @@ +package com.droiddeck.launcher.glasses + +import java.util.concurrent.ExecutionException +import java.util.concurrent.Executors +import java.util.concurrent.Future + +internal class StereoInferenceRunner : AutoCloseable { + private val worker = Executors.newSingleThreadExecutor { task -> + Thread(task, "viture-right-hand").apply { isDaemon = true } + } + + fun onRight(action: () -> T): T = worker.submit { action() }.completed() + + fun pair(left: () -> T, right: () -> T): Pair { + val pending = worker.submit { right() } + val result = try { left() } catch (error: Throwable) { + try { pending.completed() } catch (other: Throwable) { if (other !== error) error.addSuppressed(other) } + throw error + } + return result to pending.completed() + } + + override fun close() { worker.shutdown() } + + private fun Future.completed(): T { + var interrupted = false + try { + while (true) { + try { return get() } + catch (e: InterruptedException) { interrupted = true } + catch (e: ExecutionException) { throw e.cause ?: e } + } + } finally { + // Native inference must finish before either camera's pixels or detector can be reused. + if (interrupted) Thread.currentThread().interrupt() + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoJoyConFlow.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoJoyConFlow.kt new file mode 100644 index 0000000000..35b7e5b90a --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoJoyConFlow.kt @@ -0,0 +1,72 @@ +package com.droiddeck.launcher.glasses + +import org.opencv.core.* +import org.opencv.video.Video + +internal class StereoJoyConFlow : AutoCloseable { + data class Points(val left: List, val right: List, val seedNs: Long) + private val previousLeft = Mat() + private val previousRight = Mat() + private val tracks = arrayOfNulls(2) + private var previousTime = 0L + + fun reset() { + previousTime = 0 + tracks.fill(null) + previousLeft.release(); previousRight.release() + } + + fun begin(left: Mat, right: Mat, time: Long) { + for (side in 0..1) { + val old = tracks[side] ?: continue + if (!JoyConFlowGate.fresh(old.seedNs, previousTime, time) || + previousLeft.size() != left.size() || previousRight.size() != right.size()) { + tracks[side] = null + continue + } + tracks[side] = try { + Points(follow(previousLeft, left, old.left), follow(previousRight, right, old.right), old.seedNs) + } catch (e: CvException) { + android.util.Log.w("StereoJoyConFlow", "Discarding failed optical flow", e) + null + } + } + } + + fun points(side: Int): Points? = tracks[side] + + fun seed(side: Int, left: Point, right: Point, time: Long) { + tracks[side] = Points(listOf(Point(left.x, left.y)), listOf(Point(right.x, right.y)), time) + } + + fun end(left: Mat, right: Mat, time: Long) { + left.copyTo(previousLeft); right.copyTo(previousRight); previousTime = time + } + + private fun follow(previous: Mat, current: Mat, points: List): List { + val indices = points.indices.filter { points[it].x.isFinite() && points[it].y.isFinite() } + val result = MutableList(points.size) { missing() } + if (indices.isEmpty()) return result + val before = MatOfPoint2f(*indices.map { points[it] }.toTypedArray()) + val after = MatOfPoint2f(); val back = MatOfPoint2f() + val forwardStatus = MatOfByte(); val backStatus = MatOfByte() + val error = MatOfFloat(); val backError = MatOfFloat() + try { + Video.calcOpticalFlowPyrLK(previous, current, before, after, forwardStatus, error) + Video.calcOpticalFlowPyrLK(current, previous, after, back, backStatus, backError) + val next = after.toArray(); val returned = back.toArray() + val valid = forwardStatus.toArray(); val validBack = backStatus.toArray(); val errors = error.toArray() + for ((i, index) in indices.withIndex()) { + val n = next[i]; val b = returned[i]; val p = points[index] + if (JoyConFlowGate.point(n.x,n.y,b.x,b.y,p.x,p.y,errors[i],valid[i].toInt()!=0, + validBack[i].toInt()!=0,current.cols(),current.rows())) result[index] = n + } + } finally { + listOf(before, after, back, forwardStatus, backStatus, error, backError).forEach(Mat::release) + } + return result + } + + private fun missing() = Point(Double.NaN, Double.NaN) + override fun close() = reset() +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/StereoPointValidation.kt b/app/src/main/java/com/droiddeck/launcher/glasses/StereoPointValidation.kt new file mode 100644 index 0000000000..26f1c0cdcf --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/StereoPointValidation.kt @@ -0,0 +1,21 @@ +package com.droiddeck.launcher.glasses + +import kotlin.math.abs +import kotlin.math.hypot + +internal object StereoPointValidation { + fun reconstruct(homogeneous: DoubleArray, left: DoubleArray, right: DoubleArray, + p1: DoubleArray, p2: DoubleArray): SpatialVector? { + if (homogeneous.size != 4 || left.size != 2 || right.size != 2 || p1.size != 12 || p2.size != 12) return null + val w = homogeneous[3] + if (!w.isFinite() || abs(w) < 1e-8) return null + val v = DoubleArray(3) { homogeneous[it]/w } + if (v.any { !it.isFinite() } || v[2] !in 0.15..1.5) return null + for ((projection,pixel) in listOf(p1 to left,p2 to right)) { + val q = DoubleArray(3) { row -> (0..2).sumOf { projection[row*4+it]*v[it] } + projection[row*4+3] } + if (q.any { !it.isFinite() } || pixel.any { !it.isFinite() } || q[2] <= 0 || + hypot(q[0]/q[2]-pixel[0],q[1]/q[2]-pixel[1]) > 3.0) return null + } + return SpatialVector(v[0].toFloat(),v[1].toFloat(),v[2].toFloat()) + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/TrackingRecovery.kt b/app/src/main/java/com/droiddeck/launcher/glasses/TrackingRecovery.kt new file mode 100644 index 0000000000..aeba262236 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/TrackingRecovery.kt @@ -0,0 +1,17 @@ +package com.droiddeck.launcher.glasses + +internal enum class TrackingRecovery { + DISCONNECTED, LOST, RECENTER, STABILIZING; + + companion object { + fun forSession(active: Boolean, connected: Boolean, status: SpatialTrackingStatus): TrackingRecovery? = when { + !active -> null + !connected -> DISCONNECTED + status.trackingValid -> null + !status.headFresh -> LOST + status.recenterPending -> STABILIZING + status.needsRecenter -> RECENTER + else -> LOST + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/UvcRgbDiagnostic.kt b/app/src/main/java/com/droiddeck/launcher/glasses/UvcRgbDiagnostic.kt new file mode 100644 index 0000000000..6bd9c6b151 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/glasses/UvcRgbDiagnostic.kt @@ -0,0 +1,32 @@ +package com.droiddeck.launcher.glasses + +internal object UvcRgbDiagnostic { + val available: Boolean by lazy { + runCatching { System.loadLibrary("droiddeck_uvc"); true } + .onFailure { android.util.Log.w("UvcRgbDiagnostic", "Direct UVC transport unavailable", it) }.getOrDefault(false) + } + external fun nativeSnapshot(fd: Int, width: Int, height: Int, fps: Int, durationMs: Int, + metadata: LongArray, logFd: Int): ByteArray? +} + +internal data class UvcStreamHealth(val observationMs: Double, val observedFps: Double, + val maximumGapMs: Double, val healthy: Boolean) { + companion object { + // Health requires the full requested window, 80% of requested FPS, and no gap + // (including the final silent interval) above max(250 ms, three frame periods). + fun assess(metadata: LongArray, requestedFps: Int, durationMs: Int): UvcStreamHealth { + require(metadata.size == 14 && requestedFps > 0 && durationMs > 0) + val first = metadata[7] + val last = metadata[6] + val end = metadata[12] + val window = if (first > 0 && end > first) end-first else 0 + val frames = metadata[9] + val fps = if (window > 0 && frames > 1) (frames-1)*1e9/window else 0.0 + val maximumGapMs = maxOf(metadata[8],metadata[13],(end-last).coerceAtLeast(0))/1e6 + val healthy = metadata[4] == 0L && first > 0 && last in first..end && frames >= 2 && + window >= durationMs*1_000_000L && fps >= requestedFps*0.8 && + maximumGapMs <= maxOf(250.0,3000.0/requestedFps) + return UvcStreamHealth(window/1e6,fps,maximumGapMs,healthy) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt b/app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt index 6c64500d55..4d3147d65d 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt @@ -48,11 +48,21 @@ object VitureProtocol { Family.BEAST -> 58f } - override fun mode(hz: Int, sbs: Boolean): Int = when { - tall && sbs -> if (hz >= 90 && sbs90) 0x45 else 0x42 - tall -> when { hz >= 120 -> 0x44; hz >= 90 -> 0x43; else -> 0x41 } - sbs -> if (hz >= 90 && sbs90) 0x35 else 0x32 - else -> when { hz >= 120 -> 0x34; hz >= 90 -> 0x33; else -> 0x31 } + override val resolutions: List get() = buildList { + add(GlassesResolution(1920, 1080)) + if (tall) add(GlassesResolution(1920, 1200)) + } + + override fun mode(hz: Int, sbs: Boolean): Int = mode(hz, sbs, null) + + override fun mode(hz: Int, sbs: Boolean, resolution: GlassesResolution?): Int { + val useTall = tall && (resolution == null || resolution !in resolutions || resolution.height == 1200) + return when { + useTall && sbs -> if (hz >= 90 && sbs90) 0x45 else 0x42 + useTall -> when { hz >= 120 -> 0x44; hz >= 90 -> 0x43; else -> 0x41 } + sbs -> if (hz >= 90 && sbs90) 0x35 else 0x32 + else -> when { hz >= 120 -> 0x34; hz >= 90 -> 0x33; else -> 0x31 } + } } override fun modeForStep(step: Int): Int? = if (tall) null else when (step) { diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdk.kt b/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdk.kt index 21742a9d18..1b5f09e3d9 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdk.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdk.kt @@ -15,8 +15,16 @@ internal object VitureSdk { fun marketName(pid: Int): String? = if (available) nativeMarketName(pid) else null external fun nativeAvailable(): Boolean external fun nativeMarketName(pid: Int): String? - external fun nativeOpen(pid: Int, fd: Int, cacheDirectory: String): Long + external fun nativeOpen(pid: Int, fd: Int, cacheDirectory: String, spatial: Boolean = false): Long + external fun nativeSpatialPose(token: Long, pose: FloatArray, state: IntArray): Long + external fun nativeCapture(token: Long, enabled: Boolean, ratePermille: Int) + external fun nativeStereo(token: Long, left: java.nio.ByteBuffer, right: java.nio.ByteBuffer, metadata: DoubleArray, head: FloatArray, waitForPose: Boolean): Long + external fun nativeCameraSynchronized(token: Long, sourceSeconds: Double): Boolean + external fun nativeRgbSnapshot(vid: Int, pid: Int, fd: Int, metadata: LongArray, logFd: Int): ByteArray? external fun nativeType(token: Long): Int + external fun nativeFirmware(token: Long): String? + external fun nativeSerialHash(token: Long): ByteArray? + external fun nativeSpatialDiagnostics(token: Long): DoubleArray? external fun nativeTracking(token: Long, enabled: Boolean): Int external fun nativeCommand(token: Long, command: Int, value: Int): Int /** Returns CLOCK_BOOTTIME receipt time, zero for no new pose, or a negative SDK error. */ @@ -34,6 +42,11 @@ internal object VitureSdk { const val SET_FILM = 7 } +internal object VitureSpatialIdentity { + fun fromSerialHash(hash: ByteArray?): String? = hash?.takeIf { it.size == 32 && it.any { b -> b != 0.toByte() } } + ?.joinToString("", prefix = "viture:sn-sha256:") { "%02x".format(it.toInt() and 0xff) } +} + internal object VitureSdkPose { // Pro 2 hardware captures use OpenGL axes despite the generic Gen2 callback's // NWU documentation. Keep that model-specific exception out of other Gen2 devices. diff --git a/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdkLink.kt b/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdkLink.kt index 571c995aad..36ceedf6e7 100644 --- a/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdkLink.kt +++ b/app/src/main/java/com/droiddeck/launcher/glasses/VitureSdkLink.kt @@ -13,13 +13,21 @@ internal class VitureSdkLink private constructor( private val token: Long, private val listener: Listener, family: VitureProtocol.Family?, + private val spatial: Boolean, ) : GlassesLink { interface Listener { fun onValue(msgId: Int, value: Int) fun onPose(q: FloatArray, timeNs: Long) + fun onSpatial(pose: FloatArray, timeNs: Long, valid: Boolean) {} fun onLost() } + internal val sdkToken get() = token + internal val spatialEnabled get() = spatial + internal val firmware = VitureSdk.nativeFirmware(token) + internal fun spatialDiagnostics() = if (running && spatial) VitureSdk.nativeSpatialDiagnostics(token) else null + internal val isCarina = VitureSdk.nativeType(token) == VitureSdk.CARINA + internal val spatialIdentity = if (isCarina) VitureSpatialIdentity.fromSerialHash(VitureSdk.nativeSerialHash(token)) else null private val lock = Any() @Volatile private var running = true @Volatile private var tracking = false @@ -71,6 +79,8 @@ internal class VitureSdkLink private constructor( private fun poll() { val pose = FloatArray(4) + val spatialPose = FloatArray(7) + val spatialStatus = IntArray(1) val event = IntArray(2) var failures = 0 while (running) { @@ -84,7 +94,14 @@ internal class VitureSdkLink private constructor( 3 -> listener.onValue(VitureProtocol.MSG_FILM, event[1]) } } - if (!running || !tracking) 0L else VitureSdk.nativePose(token, pose) + if (!running || !tracking) 0L else if (spatial && isCarina) { + val time = VitureSdk.nativeSpatialPose(token, spatialPose, spatialStatus) + if (time > 0) listener.onSpatial(spatialPose, time, spatialStatus[0] == 0) + if (spatialStatus[0] == 0) { + spatialPose.copyInto(pose, 0, 3, 7) + time + } else if (spatialStatus[0] < 0) spatialStatus[0].toLong() else 0L + } else VitureSdk.nativePose(token, pose) } if (timestamp > 0) { failures = 0 @@ -113,15 +130,15 @@ internal class VitureSdkLink private constructor( companion object { fun open(usb: UsbManager, device: UsbDevice, cacheDirectory: File, listener: Listener, - family: VitureProtocol.Family? = null): VitureSdkLink? { + family: VitureProtocol.Family? = null, spatial: Boolean = false): VitureSdkLink? { if (!VitureSdk.available) return null val conn = usb.openDevice(device) ?: return null val token = runCatching { cacheDirectory.mkdirs() - VitureSdk.nativeOpen(device.productId, conn.fileDescriptor, cacheDirectory.absolutePath) + VitureSdk.nativeOpen(device.productId, conn.fileDescriptor, cacheDirectory.absolutePath, spatial) }.onFailure { Log.w("VitureSdkLink", "SDK initialization failed", it) }.getOrDefault(0) if (token <= 0) { conn.close(); return null } - return runCatching { VitureSdkLink(conn, token, listener, family) }.getOrElse { + return runCatching { VitureSdkLink(conn, token, listener, family, spatial) }.getOrElse { VitureSdk.nativeClose(token) conn.close() Log.w("VitureSdkLink", "SDK worker could not start", it) diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/Cardboard.kt b/app/src/main/java/com/droiddeck/launcher/gpu/Cardboard.kt index 90de91e87f..a9fd9ef836 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/Cardboard.kt +++ b/app/src/main/java/com/droiddeck/launcher/gpu/Cardboard.kt @@ -42,12 +42,13 @@ data class Cardboard( companion object { const val SOURCE_SCREEN = 0 const val SOURCE_SBS = 1 + const val SOURCE_FLAT = 2 val OFF = Cardboard() fun decode(json: JSONObject): Cardboard = Cardboard( enabled = json.optBoolean("enabled", false), - source = if (json.optInt("source", SOURCE_SCREEN) == SOURCE_SBS) SOURCE_SBS else SOURCE_SCREEN, + source = json.optInt("source", SOURCE_SCREEN).takeIf { it in SOURCE_SCREEN..SOURCE_FLAT } ?: SOURCE_SCREEN, viewer = Viewer.byId(json.optString("viewer", Viewer.CARDBOARD_V2.id)).id, ipdMm = json.optInt("ipdMm", 64).coerceIn(50, 80), screenWidthDm = json.optInt("screenWidthDm", 40).coerceIn(5, 200), @@ -102,7 +103,8 @@ object HeadPose { class Reference(val basis: FloatArray, val tilt: FloatArray) - fun recenter(screenToWorld: FloatArray): Reference { + fun recenter(screenToWorld: FloatArray, centerView: Boolean = false): Reference { + if (centerView) return Reference(screenToWorld.copyOf(), IDENTITY) val fz = -screenToWorld[8] val flat = kotlin.math.abs(fz) > FLAT_SIN var fx = if (flat) screenToWorld[1] else -screenToWorld[2] diff --git a/app/src/main/java/com/droiddeck/launcher/gpu/HeadTracker.kt b/app/src/main/java/com/droiddeck/launcher/gpu/HeadTracker.kt index afe8226174..026cef9361 100644 --- a/app/src/main/java/com/droiddeck/launcher/gpu/HeadTracker.kt +++ b/app/src/main/java/com/droiddeck/launcher/gpu/HeadTracker.kt @@ -8,9 +8,11 @@ import android.hardware.SensorManager import android.os.Handler import android.os.HandlerThread import android.util.Log +import com.droiddeck.launcher.glasses.SpatialTracking import com.droiddeck.launcher.wayland.WaylandCompositor -class HeadTracker(context: Context, private val glasses: Boolean = false, private val rotation: () -> Int) : SensorEventListener { +class HeadTracker(context: Context, private val glasses: Boolean = false, val centerView: Boolean = false, + private val rotation: () -> Int) : SensorEventListener { private val sensors = context.getSystemService(Context.SENSOR_SERVICE) as SensorManager private val sensor: Sensor? = sensors.getDefaultSensor(Sensor.TYPE_GAME_ROTATION_VECTOR) ?: sensors.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR) @@ -26,7 +28,12 @@ class HeadTracker(context: Context, private val glasses: Boolean = false, privat synchronized(glassesLock) { if (!started) return@PoseSink latest = m - apply(m) + if (SpatialTracking.enabled) { + SpatialTracking.session.view(centerView)?.let { pose -> + WaylandCompositor.nativeSetCardboardSpatialPose(pose.rotation.matrix(), pose.position.array(), + SpatialTracking.session.valid(System.nanoTime())) + } + } else apply(m) } } @@ -64,6 +71,7 @@ class HeadTracker(context: Context, private val glasses: Boolean = false, privat synchronized(glassesLock) { if (!started) return started = false + SpatialTracking.publish(System.nanoTime()) WaylandCompositor.nativeSetCardboardPose(HeadPose.IDENTITY, false) } com.droiddeck.launcher.glasses.Glasses.clearPoseSink(glassesSink) @@ -77,6 +85,7 @@ class HeadTracker(context: Context, private val glasses: Boolean = false, privat } fun recenter() { + if (glasses && SpatialTracking.enabled) { SpatialTracking.recenter(centerView); return } recenterPending = true if (glasses) synchronized(glassesLock) { if (started) latest?.let { apply(it) } } else latest?.let { apply(it) } @@ -90,7 +99,7 @@ class HeadTracker(context: Context, private val glasses: Boolean = false, privat } private fun apply(screenToWorld: FloatArray) { - val ref = reference.takeUnless { recenterPending } ?: HeadPose.recenter(screenToWorld).also { + val ref = reference.takeUnless { recenterPending } ?: HeadPose.recenter(screenToWorld, centerView).also { reference = it recenterPending = false } diff --git a/app/src/main/java/com/droiddeck/launcher/input/JoyConVr.kt b/app/src/main/java/com/droiddeck/launcher/input/JoyConVr.kt index 8b9991a745..abbefe10e7 100644 --- a/app/src/main/java/com/droiddeck/launcher/input/JoyConVr.kt +++ b/app/src/main/java/com/droiddeck/launcher/input/JoyConVr.kt @@ -91,6 +91,10 @@ class JoyConVr( worker.post { hands.forEach { it?.release() } } } + fun recenter() { + worker.post { hands.forEach { it?.recenter() } } + } + fun close() { worker.post { closed = true @@ -195,9 +199,7 @@ class JoyConVr( private val hold = Runnable { if (!systemDown || held) return@Runnable held = true - recenter++ - confirm() - publish() + recenter() } private val tapEnd = Runnable { systemTap = false @@ -281,6 +283,13 @@ class JoyConVr( publish() } + fun recenter() { + if (!live) return + recenter++ + confirm() + publish() + } + fun stop() { live = false runCatching { sensors.unregisterListener(this) } diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt index 777507a7ad..e7f393fd87 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/BwrapSpawner.kt @@ -36,7 +36,7 @@ object BwrapSpawner { return } server = socket - FileUtils.delete(File(app.cacheDir, "bwrap")) + FileUtils.delete(File(LinuxRuntime.liveDir(app), "bwrap")) Thread({ while (true) { val client = try { socket.accept() } catch (e: IOException) { Log.e(TAG, "accept", e); break } @@ -47,7 +47,7 @@ object BwrapSpawner { private fun serve(context: Context, client: LocalSocket) { val id = seq.incrementAndGet() - val dir = File(context.cacheDir, "bwrap/$id") + val dir = File(LinuxRuntime.liveDir(context), "bwrap/$id") client.use { val out = DataOutputStream(client.outputStream) try { @@ -239,12 +239,12 @@ object BwrapSpawner { } private fun genericCpuinfo(context: Context): File? = try { - val out = File(context.cacheDir, "cpuinfo-generic") + val out = File(LinuxRuntime.liveDir(context), "cpuinfo-generic") val text = File("/proc/cpuinfo").readLines() .filterNot { it.startsWith("CPU implementer") || it.startsWith("CPU part") || it.startsWith("CPU variant") || it.startsWith("CPU revision") } .joinToString("\n", postfix = "\n") if (!out.isFile || out.readText() != text) { - val staged = File.createTempFile("cpuinfo", null, context.cacheDir) + val staged = File.createTempFile("cpuinfo", null, LinuxRuntime.liveDir(context)) staged.writeText(text) if (!staged.renameTo(out)) staged.delete() } @@ -290,7 +290,7 @@ object BwrapSpawner { builder.environment().apply { clear() put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path) - put("PROOT_TMP_DIR", context.cacheDir.path) + put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(context).path) if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1") LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) } } diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/GuestCommand.kt b/app/src/main/java/com/droiddeck/launcher/runtime/GuestCommand.kt index 2db2c70419..9c65c426ae 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/GuestCommand.kt +++ b/app/src/main/java/com/droiddeck/launcher/runtime/GuestCommand.kt @@ -46,7 +46,7 @@ object GuestCommand { val builder = ProcessBuilder(cmd).directory(root).redirectErrorStream(true) builder.environment().apply { put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path) - put("PROOT_TMP_DIR", context.cacheDir.path) + put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(context).path) if (linkDir != null) put("PROOT_L2S_DIR", linkDir.path) if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1") LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) } diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java index 76ef0995ca..f7f68d6da3 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntime.java @@ -48,6 +48,19 @@ public final class LinuxRuntime { return new File(context.getFilesDir(), "session"); } + public static File liveDir(Context context) { + // Android may evict cache files even while guest processes are using them. + File dir = new File(context.getNoBackupFilesDir(), "guest-runtime"); + dir.mkdirs(); + return dir; + } + + public static File prootTempDir(Context context) { + File dir = new File(liveDir(context), "proot"); + dir.mkdirs(); + return dir; + } + private static final String HOST_DIR = "opt/android-host"; public static File prootBinary(Context context) { @@ -151,6 +164,7 @@ public final class LinuxRuntime { bind(cmd, new File(root, "etc/droiddeck/empty").getPath() + ":/sys/fs/selinux"); bind(cmd, context.getFilesDir().getPath()); bind(cmd, context.getCacheDir().getPath()); + bind(cmd, liveDir(context).getPath()); if (runtimeDir != null) { bind(cmd, runtimeDir.getPath()); bind(cmd, runtimeDir.getPath() + ":" + GUEST_RUNTIME_DIR); @@ -159,7 +173,7 @@ public final class LinuxRuntime { if (externalStorage != null && externalStorage.isDirectory()) { bind(cmd, externalStorage.getPath()); } - File shm = new File(context.getCacheDir(), "shm"); + File shm = new File(liveDir(context), "shm"); shm.mkdirs(); bind(cmd, shm.getPath() + ":/dev/shm"); bindSystemFonts(cmd, root); @@ -222,7 +236,7 @@ public final class LinuxRuntime { long major = ((dev >> 8) & 0xfff) | ((dev >> 32) & ~0xfffL); long minor = (dev & 0xff) | ((dev >> 12) & ~0xffL); String node = "renderD" + minor; - File base = new File(context.getCacheDir(), "drm"); + File base = new File(liveDir(context), "drm"); File dri = new File(base, "dri"); File device = new File(base, "sys/" + major + ":" + minor + "/device"); File drm = new File(device, "drm/" + node); diff --git a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntimeInstaller.java b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntimeInstaller.java index d74022e91c..efecb6fb20 100644 --- a/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntimeInstaller.java +++ b/app/src/main/java/com/droiddeck/launcher/runtime/LinuxRuntimeInstaller.java @@ -367,12 +367,17 @@ public final class LinuxRuntimeInstaller { } public static Removal beginUninstall(Context context) { - if (com.droiddeck.launcher.session.SessionState.INSTANCE.getRunning()) return null; - com.droiddeck.launcher.session.SessionPhase phase = com.droiddeck.launcher.session.SessionState.INSTANCE.getPhase(); - if (phase != com.droiddeck.launcher.session.SessionPhase.IDLE && phase != com.droiddeck.launcher.session.SessionPhase.FAILED) return null; + if (sessionInUse()) return null; return beginUninstall(context.getApplicationContext(), LinuxRuntime.rootDir(context)); } + private static boolean sessionInUse() { + com.droiddeck.launcher.session.SessionState session = com.droiddeck.launcher.session.SessionState.INSTANCE; + com.droiddeck.launcher.session.SessionPhase phase = session.getPhase(); + return session.getRunning() || + (phase != com.droiddeck.launcher.session.SessionPhase.IDLE && phase != com.droiddeck.launcher.session.SessionPhase.FAILED); + } + static Removal beginUninstall(Context app, File root) { synchronized (JOB_LOCK) { if (running != null) return null; @@ -397,6 +402,7 @@ public final class LinuxRuntimeInstaller { if (!started.compareAndSet(false, true)) return join(job, listener); if (listener != null) job.listeners.add(listener); try { + requireStopped(); report(text(app, R.string.rtinst_removing), -1); final long[] removed = {0}; final long[] lastShown = {0}; @@ -423,6 +429,8 @@ public final class LinuxRuntimeInstaller { if (!discard(leftover, progress)) throw new IOException("Cannot remove " + leftover); } emptyTrash(root.getParentFile()); + requireStopped(); + if (app != null) RuntimeFileTree.delete(new File(app.getNoBackupFilesDir(), "guest-runtime"), null); job.ok = true; report(text(app, R.string.rtinst_removed), 100); return true; @@ -436,6 +444,11 @@ public final class LinuxRuntimeInstaller { job.done.countDown(); } } + + private void requireStopped() throws IOException { + if (Thread.currentThread().isInterrupted()) throw new IOException("Runtime removal was interrupted"); + if (app != null && sessionInUse()) throw new IOException("A session is still using the runtime"); + } private void report(String stage, int percent) { job.stage = stage; job.percent = percent; diff --git a/app/src/main/java/com/droiddeck/launcher/session/FexCatalog.kt b/app/src/main/java/com/droiddeck/launcher/session/FexCatalog.kt new file mode 100644 index 0000000000..73f42cb141 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/session/FexCatalog.kt @@ -0,0 +1,71 @@ +package com.droiddeck.launcher.session + +import android.content.Context +import android.util.Log +import com.droiddeck.launcher.core.DownloadSource +import com.droiddeck.launcher.core.Downloader +import org.json.JSONObject +import java.io.File + +/** + * The FEX build DroidDeck-Components' fex.json names for the x86-64 client. A session uses the last copy read. + * Components' build-fex.yml replaces the archive on its single `fex` release and records the build's version; + * a release per build (fex-2610-r5) is still read. + */ +object FexCatalog { + private const val TAG = "FexCatalog" + const val CATALOG_URL = "https://raw.githubusercontent.com/Droid-Deck/DroidDeck-Components/main/fex.json" + private const val RELEASES = "https://github.com/Droid-Deck/DroidDeck-Components/releases/download/" + private const val REFRESH_MS = 10 * 60 * 1000L + private val TAG_FORMAT = Regex("""fex-\d+-r\d+""") + private val VERSION_FORMAT = Regex("""\d+-r\d+""") + private val SHA256 = Regex("[0-9a-f]{64}") + + data class Build(val tag: String, val url: String, val sha256: String) + + @Volatile private var refreshedAt = 0L + + private fun file(context: Context) = File(context.filesDir, "fex-catalog.json") + + internal fun parse(text: String): Build? = runCatching { + val o = JSONObject(text) + val release = o.getString("release") + val url = o.getString("url") + val sha = o.getString("sha256").lowercase() + val version = o.optString("version") + val tag = when { + TAG_FORMAT.matches(release) -> release + release == "fex" && VERSION_FORMAT.matches(version) -> "fex-$version" + else -> return@runCatching null + } + Build(tag, url, sha).takeIf { url == "$RELEASES$release/fex.tzst" && SHA256.matches(sha) } + }.getOrNull() + + fun cached(context: Context): Build? = runCatching { parse(file(context).readText()) }.getOrNull() + + /** Reads fex.json straight from GitHub (a digest never comes from a mirror), at most every ten minutes. */ + @Synchronized + fun refresh(context: Context, now: Long = System.currentTimeMillis()): Build? { + if (now - refreshedAt < REFRESH_MS) return cached(context) + refreshedAt = now + val text = Downloader.downloadDirect(CATALOG_URL) ?: return cached(context) + val build = parse(text) ?: run { + Log.w(TAG, "fex.json not usable; keeping the last one") + return cached(context) + } + runCatching { + val f = file(context) + val tmp = File(f.path + ".tmp") + tmp.writeText(text) + if (!tmp.renameTo(f)) tmp.delete() + } + return build + } + + /** For droiddeck-steam-x64: the build and every source its archive may come from (it checks the sha256). */ + fun environment(build: Build, sources: List = DownloadSource.candidates(build.url)): List = listOf( + "BL_FEX_TAG=${build.tag}", + "BL_FEX_SHA256=${build.sha256}", + "BL_FEX_URLS=" + sources.joinToString(" "), + ) +} diff --git a/app/src/main/java/com/droiddeck/launcher/session/ProtonExtras.kt b/app/src/main/java/com/droiddeck/launcher/session/ProtonExtras.kt index e88aa819ce..42c0deeb6f 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/ProtonExtras.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/ProtonExtras.kt @@ -225,7 +225,7 @@ object ProtonExtras { .redirectErrorStream(true) val hostEnv = process.environment() hostEnv["PROOT_LOADER"] = LinuxRuntime.prootLoader(context).path - hostEnv["PROOT_TMP_DIR"] = context.cacheDir.path + hostEnv["PROOT_TMP_DIR"] = LinuxRuntime.prootTempDir(context).path LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { hostEnv["LD_LIBRARY_PATH"] = it } val child = process.start() var placed: String? = null diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt index 32e149aebf..681287c868 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionFiles.kt @@ -121,13 +121,14 @@ object SessionFiles { "droiddeck/driver.vrdrivermanifest", "droiddeck/resources/settings/default.vrsettings", "layer/libVkLayer_droiddeck_vr.so", + "layer/libdroiddeck_vr_scheduling.so", "layer/VK_LAYER_DROIDDECK_vr.json", ) + handModels).map { "usr/local/lib/droiddeck-vr/$it" to "usr/local/lib/droiddeck-vr/$it" } + listOf("usr/local/lib/droiddeck-vr/layer/VK_LAYER_DROIDDECK_vr_implicit.json" to "usr/share/vulkan/implicit_layer.d/droiddeck_vr.json") val fexPreloads = listOf("x86_64", "i386").flatMap { arch -> listOf("libblsession.so", "libfakeinput.so", "libfaultreport.so").map { "$arch/$it" to "usr/local/lib/droiddeck-fex/$arch/$it" } - } + listOf("libthunkaudit.so", "libvulkan-thunk.so", "libwebkitinput.so").map { "x86_64/$it" to "usr/local/lib/droiddeck-fex/x86_64/$it" } + } + listOf("libvulkan-thunk.so", "libwebkitinput.so").map { "x86_64/$it" to "usr/local/lib/droiddeck-fex/x86_64/$it" } val optional = (arrayOf( "usr/local/bin/gamescope" to "usr/local/bin/gamescope", "usr/local/lib/droiddeck/uruntime" to "usr/local/lib/droiddeck/uruntime", diff --git a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt index 6a65677175..09b99d2441 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SessionService.kt @@ -415,7 +415,7 @@ class SessionService : Service() { Log.i(TAG, "run: $program (${SessionState.programArgs.size} arguments) under gamescope") } - FileUtils.clear(File(cacheDir, "shm")) + FileUtils.clear(File(LinuxRuntime.liveDir(this), "shm")) val binds = sessionBinds(controllersOn, fakeInputDir, sessionDir, guest, sessionRoot, runtimeDir) val fastPathKey = if (ProotFastPath.enabled(this)) { @@ -440,7 +440,7 @@ class SessionService : Service() { val hostEnv = HostEnvironment() hostEnv["PROOT_LOADER"] = LinuxRuntime.prootLoader(this).path - hostEnv["PROOT_TMP_DIR"] = cacheDir.path + hostEnv["PROOT_TMP_DIR"] = LinuxRuntime.prootTempDir(this).path if (SessionPrefs.prootNoSeccomp(this)) { hostEnv["PROOT_NO_SECCOMP"] = "1" Log.i(TAG, "proot: seccomp acceleration off by request") @@ -591,6 +591,7 @@ class SessionService : Service() { SessionState.steamClientArch?.let { arch -> guest.add("BL_STEAM_CLIENT_ARCH=$arch") SessionPaths.current()?.let { SessionArtifacts.recordClient(it, arch) } + if (arch == "x86_64") FexCatalog.cached(this)?.let { guest.addAll(FexCatalog.environment(it)) } } if (SessionState.mode == MODE_STEAM) { guest.add("BL_GAMESCOPE_STRETCH_16X9=" + (if (SessionPrefs.stretch16x9(this)) "1" else "0")) @@ -1375,6 +1376,9 @@ class SessionService : Service() { val failureStatus = SessionState.failureStatus ?: status SessionEvents.fail(code, message, failureStatus) } + SessionState.steamVr = false + com.droiddeck.launcher.glasses.Glasses.cancelSteamVrStart() + com.droiddeck.launcher.glasses.Glasses.setVrActive(false) com.droiddeck.launcher.glasses.Glasses.set3dForVr(false) SessionState.notifyEnded(status) stopForeground(STOP_FOREGROUND_REMOVE) diff --git a/app/src/main/java/com/droiddeck/launcher/session/SteamDeckPad.kt b/app/src/main/java/com/droiddeck/launcher/session/SteamDeckPad.kt index 4b8daf5179..db9884dd53 100644 --- a/app/src/main/java/com/droiddeck/launcher/session/SteamDeckPad.kt +++ b/app/src/main/java/com/droiddeck/launcher/session/SteamDeckPad.kt @@ -155,7 +155,7 @@ object SteamDeckPad { val listing = listingDir(sessionRoot) for (name in listOf("sys/bus", "sys/class", "sys/devices", "class/hidraw", "bus")) File(listing, name).mkdirs() - link(File(context.cacheDir, "drm/sys/$MAJOR:$MINOR"), HIDRAW) + link(File(LinuxRuntime.liveDir(context), "drm/sys/$MAJOR:$MINOR"), HIDRAW) val udevData = File(LinuxRuntime.rootDir(context), "run/udev/data").apply { mkdirs() } File(udevData, "c$MAJOR:$MINOR").writeText("I:1\nE:ID_INPUT=1\nE:ID_INPUT_JOYSTICK=1\n") @@ -183,7 +183,7 @@ object SteamDeckPad { link(File(dir(TOUCH_HIDRAW), "subsystem"), "/sys/class/hidraw") link(File(dir(TOUCH_HIDRAW), "device"), TOUCH_HID) link(File(hidrawClass, TOUCH_NODE), TOUCH_HIDRAW) - link(File(context.cacheDir, "drm/sys/$MAJOR:$TOUCH_MINOR"), TOUCH_HIDRAW) + link(File(LinuxRuntime.liveDir(context), "drm/sys/$MAJOR:$TOUCH_MINOR"), TOUCH_HIDRAW) File(udevData, "c$MAJOR:$TOUCH_MINOR").writeText("I:1\nE:ID_INPUT=1\nE:ID_INPUT_JOYSTICK=1\n") Log.i(TAG, "deck pad: /dev/$TOUCH_NODE described as Steam's touch controller (0000:11fb)") } @@ -220,7 +220,7 @@ object SteamDeckPad { link(File(dir(hidraw), "subsystem"), "/sys/class/hidraw") link(File(dir(hidraw), "device"), hid) if (wired) padNodes[minor] = hidraw else link(File(hidrawClass, node), hidraw) - link(File(context.cacheDir, "drm/sys/$MAJOR:$minor"), hidraw) + link(File(LinuxRuntime.liveDir(context), "drm/sys/$MAJOR:$minor"), hidraw) File(udevData, "c$MAJOR:$minor").writeText("I:1\nE:ID_INPUT=1\nE:ID_INPUT_JOYSTICK=1\n") Log.i(TAG, "steam controller: /dev/$node described as Triton (28de:$product)") } @@ -255,7 +255,7 @@ object SteamDeckPad { link(File(dir(hidraw), "subsystem"), "/sys/class/hidraw") link(File(dir(hidraw), "device"), hid) padNodes[minor] = hidraw - link(File(context.cacheDir, "drm/sys/$MAJOR:$minor"), hidraw) + link(File(LinuxRuntime.liveDir(context), "drm/sys/$MAJOR:$minor"), hidraw) File(udevData, "c$MAJOR:$minor").writeText("I:1\nE:ID_INPUT=1\nE:ID_INPUT_JOYSTICK=1\n") Log.i(TAG, "playstation pad: /dev/$node described as 054c:$product") } diff --git a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogComet.kt b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogComet.kt index d6a4c3a605..6241778218 100644 --- a/app/src/main/java/com/droiddeck/launcher/stores/gog/GogComet.kt +++ b/app/src/main/java/com/droiddeck/launcher/stores/gog/GogComet.kt @@ -122,7 +122,7 @@ object GogComet { pb.environment().apply { remove("LD_PRELOAD"); remove("LD_AUDIT"); remove("LD_LIBRARY_PATH") put("PROOT_LOADER", LinuxRuntime.prootLoader(context).path) - put("PROOT_TMP_DIR", context.cacheDir.path) + put("PROOT_TMP_DIR", LinuxRuntime.prootTempDir(context).path) if (SessionPrefs.prootNoSeccomp(context)) put("PROOT_NO_SECCOMP", "1") LinuxRuntime.prootLibraryPath(context).takeIf { it.isNotEmpty() }?.let { put("LD_LIBRARY_PATH", it) } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt index bc70d04042..c121eb75ea 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/FrontEndSetup.kt @@ -86,6 +86,7 @@ import com.droiddeck.launcher.R private enum class CheckState { OK, WARN, BUSY } private const val STORAGE_TAB = 3 +private const val GLASSES_TAB = 5 @Composable private fun CheckRow(state: CheckState, title: String, detail: String?, divider: Boolean = true, action: (@Composable () -> Unit)? = null) { @@ -175,7 +176,7 @@ internal fun SetupPanel( onDismiss = { editDownloadPrefix = false }, onSave = { a.onDownloadPrefix(it); editDownloadPrefix = false }, ) - val tabs = listOf(stringResource(R.string.setup_tab_overview), stringResource(R.string.setup_tab_controller), stringResource(R.string.setup_tab_launcher), stringResource(R.string.setup_tab_storage), stringResource(R.string.setup_tab_diagnostics)) + val tabs = listOf(stringResource(R.string.setup_tab_overview), stringResource(R.string.setup_tab_controller), stringResource(R.string.setup_tab_launcher), stringResource(R.string.setup_tab_storage), stringResource(R.string.setup_tab_diagnostics), stringResource(R.string.setup_tab_glasses)) var tab by rememberSaveable { mutableStateOf(0) } val chipFocus = remember { List(tabs.size) { FocusRequester() } } var tabTurned by remember { mutableStateOf(false) } @@ -451,6 +452,7 @@ internal fun SetupPanel( stringResource(R.string.setup_reset_settings_button), a.onResetSettings) } } + GLASSES_TAB -> GlassesSetupPanel() } } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt index 5b8e3b30ef..0d06087307 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/GlassesPanel.kt @@ -5,8 +5,10 @@ import androidx.compose.foundation.border import androidx.compose.foundation.clickable import androidx.compose.foundation.interaction.MutableInteractionSource import androidx.compose.foundation.interaction.collectIsPressedAsState +import androidx.compose.foundation.layout.Arrangement import androidx.compose.foundation.layout.Box import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.Row import androidx.compose.foundation.layout.Spacer import androidx.compose.foundation.layout.WindowInsets import androidx.compose.foundation.layout.displayCutout @@ -42,8 +44,14 @@ import androidx.compose.runtime.collectAsState import com.droiddeck.launcher.R import com.droiddeck.launcher.glasses.Glasses import com.droiddeck.launcher.glasses.GlassesRendering +import com.droiddeck.launcher.glasses.GlassesDisplayModes +import com.droiddeck.launcher.glasses.GlassesDisplayProfile import com.droiddeck.launcher.glasses.GlassesSettings import com.droiddeck.launcher.glasses.GlassesState +import android.content.Intent +import androidx.compose.ui.platform.LocalContext +import com.droiddeck.launcher.glasses.SpatialTracking +import com.droiddeck.launcher.glasses.SpatialMeasurements import com.droiddeck.launcher.handtracking.HandTracking import java.util.Locale @@ -68,6 +76,7 @@ internal fun rememberGlasses(): Pair { internal object GlassesTab { const val DISPLAY = "display" + const val VR = "vr" const val HARDWARE = "hardware" const val TRACKING = "tracking" } @@ -75,9 +84,10 @@ internal object GlassesTab { @Composable internal fun glassesTabs(g: GlassesState): List> = buildList { add(GlassesTab.DISPLAY to stringResource(R.string.glasses_display)) + if (g.canControl || g.hasDisplay) add(GlassesTab.VR to stringResource(R.string.glasses_vr)) if (g.canControl) { - if (g.hardwareControls) add(GlassesTab.HARDWARE to stringResource(R.string.glasses_hardware)) add(GlassesTab.TRACKING to stringResource(R.string.glasses_tracking)) + if (g.hardwareControls) add(GlassesTab.HARDWARE to stringResource(R.string.glasses_hardware)) } } @@ -95,10 +105,22 @@ internal fun GlassesGroups( steamVr: @Composable () -> Unit = {}, ) { val display = tab == null || tab == GlassesTab.DISPLAY + val vr = tab == null || tab == GlassesTab.VR val picture = GlassesRendering.picture(s, g.sbs, steamVrRunning) val usesGlasses = GlassesRendering.usesGlasses(g, outputActive, steamVrRunning) + val spatialTracking = g.spatialConnected && s.positionalTracking + val spatialVr = spatialTracking && usesGlasses && steamVrRunning + val flatPicture = picture == GlassesRendering.Picture.FLAT || picture == GlassesRendering.Picture.DUPLICATED val virtualScreen = usesGlasses && picture == GlassesRendering.Picture.VIRTUAL_SCREEN val directView = usesGlasses && picture == GlassesRendering.Picture.STEREO + val menuScreen = !inSession && g.usable && s.gameOnGlasses && s.screen3dof + if (g.canControl && onRecenter != null && s.headTracking && (virtualScreen || menuScreen || (directView && steamVrRunning))) { + SettingsGroup(stringResource(R.string.glasses_quick_actions), compact = true) { + ActionRow(stringResource(R.string.glasses_recenter), + if (virtualScreen || menuScreen) stringResource(R.string.glasses_recenter_screen_hint) else null, + stringResource(R.string.cardboard_recenter_button), onRecenter) + } + } if (display) SettingsGroup(g.model) { if (g.experimental) SettingsRow(stringResource(R.string.glasses_control), stringResource(R.string.glasses_xreal_experimental)) {} val status = if (g.hasDisplay) stringResource(R.string.glasses_status, g.width, g.height, kotlin.math.round(g.hz).toInt(), @@ -119,35 +141,38 @@ internal fun GlassesGroups( ToggleRow(host, "glasses-game", stringResource(R.string.glasses_game_on), stringResource(R.string.glasses_game_on_hint), s.gameOnGlasses, chipModifier = track("glasses-game")) { Glasses.setGameOnGlasses(it) } } - if (display && (g.canControl || g.hasDisplay)) SettingsGroup(stringResource(R.string.glasses_display)) { - if (g.canControl) { - if (!g.sbs) ChoiceRow(host, "glasses-hz", stringResource(R.string.glasses_refresh), null, - listOf(60, 90, 120).map { it to "$it Hz" }, s.refreshHz, chipModifier = track("glasses-hz")) { Glasses.setRefreshHz(it) } + if (display && g.canControl && (inSession || g.sbs || g.sbsSupport == GlassesState.SBS_FAILS)) { + SettingsGroup(stringResource(R.string.glasses_display_mode)) { if (g.sbsSupport == GlassesState.SBS_FAILS && !g.sbs) { ActionRow(stringResource(R.string.glasses_3d), stringResource(R.string.glasses_3d_failed), stringResource(R.string.stores_dl_retry), { Glasses.set3d(true) }) - } else { - if (inSession || g.sbs) ToggleRow(host, "glasses-3d", stringResource(R.string.glasses_3d), stringResource(R.string.glasses_3d_hint), - g.sbs, chipModifier = track("glasses-3d")) { Glasses.set3d(it) } - if (g.sbs) { - if (g.sbs90) ChoiceRow(host, "glasses-3d-hz", stringResource(R.string.glasses_3d_refresh), null, - listOf(60, 90).map { it to "$it Hz" }, s.sbsHz, chipModifier = track("glasses-3d-hz")) { Glasses.setSbsHz(it) } - else SettingsRow(stringResource(R.string.glasses_3d_refresh), "60 Hz") {} - } - } + } else ToggleRow(host, "glasses-3d", stringResource(R.string.glasses_3d), stringResource(R.string.glasses_3d_hint), + g.sbs, chipModifier = track("glasses-3d")) { Glasses.set3d(it) } } - ToggleRow(host, "glasses-auto3d", stringResource(R.string.glasses_auto3d), stringResource(R.string.glasses_auto3d_hint), - s.auto3d, chipModifier = track("glasses-auto3d")) { Glasses.setAuto3d(it) } + } + if (display && g.canControl) { + val profiles = if (inSession) listOf(GlassesDisplayModes.profile(g.sbs, false)) + else listOf(GlassesDisplayProfile.TWO_D, GlassesDisplayProfile.THREE_D) + for (profile in profiles) SettingsGroup(stringResource(if (profile == GlassesDisplayProfile.TWO_D) + R.string.glasses_output_2d else R.string.glasses_output_3d)) { + GlassesResolutionRow(host, g, s, profile, track) + if ((profile == GlassesDisplayProfile.THREE_D) == g.sbs) GlassesRefreshRow(host, g, s, track) + } + } + if (display && (g.canControl || g.hasDisplay)) SettingsGroup(stringResource(R.string.glasses_picture_group)) { ChoiceRow(host, "glasses-picture", stringResource(R.string.glasses_picture), stringResource(R.string.glasses_picture_hint), listOf( GlassesSettings.PICTURE_AUTO to stringResource(R.string.glasses_picture_auto), GlassesSettings.PICTURE_SCREEN to stringResource(R.string.glasses_picture_screen), GlassesSettings.PICTURE_SBS to stringResource(R.string.glasses_picture_sbs), - ), s.picture3d, chipModifier = track("glasses-picture"), hintLines = 2) { Glasses.setPicture3d(it) } + ), s.picture3d, chipModifier = track("glasses-picture")) { Glasses.setPicture3d(it) } + if (g.canControl && g.supportsScreen3dof) ToggleRow(host, "glasses-3dof", + stringResource(if (g.spatialConnected && s.positionalTracking) R.string.glasses_6dof else R.string.glasses_3dof), + stringResource(R.string.glasses_3dof_hint), s.screen3dof, chipModifier = track("glasses-3dof")) { Glasses.set3dof(it) } when { - !inSession -> SettingsRow(stringResource(R.string.glasses_picture_screen), stringResource(R.string.glasses_screen_next_session)) {} + !inSession -> SettingsRow(stringResource(R.string.glasses_picture_screen), stringResource(R.string.glasses_screen_app_wide)) {} !usesGlasses -> SettingsRow(stringResource(R.string.glasses_picture_screen), stringResource(R.string.glasses_screen_no_output)) {} - picture == GlassesRendering.Picture.FLAT -> ActionRow( + flatPicture -> ActionRow( stringResource(R.string.glasses_picture_screen), stringResource(R.string.glasses_screen_flat_hint), stringResource(R.string.glasses_screen_use), { Glasses.setPicture3d(GlassesSettings.PICTURE_SCREEN) }) directView -> SettingsRow(stringResource(R.string.glasses_picture_screen), @@ -155,15 +180,44 @@ internal fun GlassesGroups( } if (virtualScreen || (!inSession && s.picture3d != GlassesSettings.PICTURE_SBS)) { SliderRow(stringResource(R.string.glasses_screen_size), null, s.screenWidthDm, 5..60, step = 1, - format = { String.format(Locale.US, "%.1f m", it / 10f) }, modifier = track("glasses-width")) { Glasses.setScreenWidthDm(it) } + format = { SpatialMeasurements.distance(it / 10f) }, modifier = track("glasses-width")) { Glasses.setScreenWidthDm(it) } SliderRow(stringResource(R.string.glasses_screen_distance), null, s.screenDistanceDm, 5..100, step = 1, - format = { String.format(Locale.US, "%.1f m", it / 10f) }, modifier = track("glasses-distance")) { Glasses.setScreenDistanceDm(it) } + format = { SpatialMeasurements.distance(it / 10f) }, modifier = track("glasses-distance")) { Glasses.setScreenDistanceDm(it) } } + } + if (vr && (g.canControl || g.hasDisplay)) SettingsGroup(stringResource(R.string.cardboard_steamvr)) { steamVr() - if ((directView && steamVrRunning) || !inSession) SliderRow(stringResource(R.string.glasses_vr_fov), stringResource(R.string.glasses_vr_fov_hint), s.vrFovDeg, + ToggleRow(host, "glasses-auto3d", stringResource(R.string.glasses_auto3d), stringResource(R.string.glasses_auto3d_hint), + s.auto3d, chipModifier = track("glasses-auto3d")) { Glasses.setAuto3d(it) } + if (g.canControl) { + GlassesResolutionRow(host, g, s, GlassesDisplayProfile.VR, track) + if (steamVrRunning && tab != null) GlassesRefreshRow(host, g, s, track) + } + SliderRow(stringResource(R.string.glasses_vr_fov), stringResource(R.string.glasses_vr_fov_hint), s.vrFovDeg, GlassesSettings.VR_FOV_MIN..GlassesSettings.VR_FOV_MAX, step = 1, format = { "$it°" }, modifier = track("glasses-vr-fov")) { Glasses.setVrFovDeg(it) } } + if ((tab == null || tab == GlassesTab.TRACKING) && g.canControl) { + SettingsGroup(stringResource(R.string.glasses_head_tracking)) { + val trackingHint = when { + inSession && !usesGlasses -> R.string.glasses_screen_no_output + spatialVr -> R.string.glasses_head_tracking_spatial_vr_hint + spatialTracking -> R.string.glasses_head_tracking_spatial_hint + inSession && flatPicture -> R.string.glasses_tracking_flat_hint + inSession && directView && !steamVrRunning -> R.string.glasses_tracking_sbs_hint + else -> R.string.glasses_head_tracking_hint + } + ToggleRow(host, "glasses-tracking", stringResource(R.string.glasses_head_tracking), stringResource(trackingHint), + s.headTracking || spatialVr, enabled = !spatialVr, + chipModifier = track("glasses-tracking")) { Glasses.setHeadTracking(it) } + } + val calibration by Glasses.calibration.collectAsState() + if (calibration.supported) SettingsGroup(stringResource(R.string.glasses_calibration)) { + GlassesCalibrationControls(calibration, + onStart = Glasses::startCalibration, onCancel = Glasses::cancelCalibration, + onReset = Glasses::resetCalibration, onDone = { onRecenter?.invoke() }) + } + } if ((tab == null || tab == GlassesTab.HARDWARE) && g.canControl && g.hardwareControls) SettingsGroup(stringResource(R.string.glasses_hardware)) { if (g.brightnessMax > 0) SliderRow(stringResource(R.string.glasses_brightness), null, g.brightness.coerceAtLeast(0), 0..g.brightnessMax, step = 1, modifier = track("glasses-brightness")) { Glasses.setBrightness(it) } @@ -172,28 +226,71 @@ internal fun GlassesGroups( if (g.hasSunblock) ToggleRow(host, "glasses-sunblock", stringResource(R.string.glasses_sunblock), stringResource(R.string.glasses_sunblock_hint), g.sunblock, chipModifier = track("glasses-sunblock")) { Glasses.setSunblock(it) } } - if ((tab == null || tab == GlassesTab.TRACKING) && g.canControl) SettingsGroup(stringResource(R.string.glasses_tracking)) { - val trackingHint = when { - inSession && !usesGlasses -> R.string.glasses_screen_no_output - inSession && picture == GlassesRendering.Picture.FLAT -> R.string.glasses_tracking_flat_hint - inSession && directView && !steamVrRunning -> R.string.glasses_tracking_sbs_hint - else -> R.string.glasses_head_tracking_hint - } - ToggleRow(host, "glasses-tracking", stringResource(R.string.glasses_head_tracking), stringResource(trackingHint), - s.headTracking, chipModifier = track("glasses-tracking")) { Glasses.setHeadTracking(it) } - if (onRecenter != null && s.headTracking && (virtualScreen || (directView && steamVrRunning))) ActionRow(stringResource(R.string.glasses_recenter), null, - stringResource(R.string.cardboard_recenter_button), onRecenter) - val calibration by Glasses.calibration.collectAsState() - if (calibration.supported) GlassesCalibrationControls(calibration, - onStart = Glasses::startCalibration, onCancel = Glasses::cancelCalibration, - onReset = Glasses::resetCalibration, onDone = { onRecenter?.invoke() }) - } val context = androidx.compose.ui.platform.LocalContext.current val hands by HandTracking.settings.collectAsState() androidx.compose.runtime.LaunchedEffect(Unit) { HandTracking.load(context) } - if ((tab == null || tab == GlassesTab.TRACKING) && g.canControl && hands.usable) SettingsGroup(stringResource(R.string.hand_camera_group)) { - HandCameraRows(host, track, inSession) + if ((tab == null || tab == GlassesTab.TRACKING) && g.canControl) { + if (g.spatialConnected) { + SettingsGroup(stringResource(R.string.glasses_experimental)) { + val spatial by SpatialTracking.status.collectAsState() + ToggleRow(host, "glasses-position", stringResource(R.string.glasses_position), stringResource(R.string.glasses_position_hint), + s.positionalTracking, chipModifier = track("glasses-position")) { Glasses.setPositionalTracking(it) } + if (s.positionalTracking) { + SettingsRow(stringResource(R.string.glasses_tracking_status), spatial.message) {} + SliderRow(stringResource(R.string.glasses_eye_height), null, s.eyeHeightCm, 50..250, step = 1, + format = SpatialMeasurements::height, modifier = track("glasses-eye-height")) { Glasses.setEyeHeight(it) } + ActionRow(stringResource(R.string.glasses_floor), null, stringResource(R.string.glasses_floor_set), Glasses::setSpatialFloor) + HandCalibrationStatus(spatial) + ActionRow(stringResource(R.string.glasses_spatial_setup), stringResource(R.string.glasses_spatial_setup_hint), + stringResource(R.string.glasses_spatial_open), { context.startActivity(Intent(context, SpatialTrackingActivity::class.java)) }) + ToggleRow(host, "glasses-hands", stringResource(R.string.glasses_hands), stringResource(R.string.glasses_hands_hint), + s.handControllers, chipModifier = track("glasses-hands")) { Glasses.setHandControllers(it) } + if (s.handControllers) ToggleRow(host, "glasses-steady-hand-aim", + stringResource(R.string.glasses_steady_hand_aim), stringResource(R.string.glasses_steady_hand_aim_hint), + s.steadyHandAim, chipModifier = track("glasses-steady-hand-aim")) { Glasses.setSteadyHandAim(it) } + } + ToggleRow(host, "glasses-joycons", stringResource(R.string.glasses_joycons), + stringResource(if (s.positionalTracking) R.string.glasses_joycons_hint else R.string.glasses_joycons_requires_position), + s.joyConTracking, enabled = s.positionalTracking, chipModifier = track("glasses-joycons")) { Glasses.setJoyConTracking(it) } + } + } + if (hands.usable) SettingsGroup(stringResource(R.string.phone_camera_tracking_group)) { + HandCameraRows(host, track, inSession) + } } + +} + +@Composable +private fun GlassesResolutionRow(host: MenuHost, g: GlassesState, s: GlassesSettings, + profile: GlassesDisplayProfile, track: (String) -> Modifier) { + val label = when (profile) { + GlassesDisplayProfile.TWO_D -> R.string.glasses_resolution_2d + GlassesDisplayProfile.THREE_D -> R.string.glasses_resolution_3d + GlassesDisplayProfile.VR -> R.string.glasses_resolution_vr + } + val choices = listOf("" to stringResource(if (profile == GlassesDisplayProfile.VR) + R.string.glasses_resolution_inherit else R.string.glasses_resolution_auto)) + + g.resolutions.map { it.key to "${it.width} × ${it.height}" } + val saved = GlassesDisplayModes.choice(s, profile) + val key = "glasses-resolution-${profile.name.lowercase()}" + ChoiceRow(host, key, stringResource(label), stringResource(R.string.glasses_resolution_hint), choices, + saved.takeIf { value -> choices.any { it.first == value } } ?: "", + enabled = !g.switching3d, chipModifier = track(key)) { Glasses.setResolution(profile, it) } +} + +@Composable +private fun GlassesRefreshRow(host: MenuHost, g: GlassesState, s: GlassesSettings, track: (String) -> Modifier) { + val rates = GlassesRendering.refreshRates(s, g).map { it to "$it Hz" } + val hint = if (g.supports30Hz && !s.gameOnGlasses) stringResource(R.string.glasses_refresh_30_hint) else null + val label = stringResource(if (g.sbs) R.string.glasses_3d_refresh else R.string.glasses_refresh) + if (rates.size > 1) { + val key = if (g.sbs) "glasses-3d-hz" else "glasses-hz" + ChoiceRow(host, key, label, hint, rates, GlassesRendering.outputHz(s, g), + enabled = !g.switching3d, chipModifier = track(key)) { + if (g.sbs) Glasses.setSbsHz(it) else Glasses.setRefreshHz(it) + } + } else SettingsRow(label, hint ?: "${rates.single().first} Hz") {} } private fun padButtonColors(tint: Int, opacity: Int, pressed: Boolean): Pair { @@ -231,28 +328,37 @@ internal fun GlassesCornerButton(slot: Int, tint: Int, opacity: Int, onClick: () } @Composable -internal fun GlassesRecenterButton(tint: Int, opacity: Int, onClick: () -> Unit) { +internal fun GlassesRecenterButton(tint: Int, opacity: Int, onRecenterJoyCons: (() -> Unit)? = null, onClick: () -> Unit) { + Box( + Modifier.fillMaxSize().windowInsetsPadding(WindowInsets.displayCutout).padding(top = 12.dp), + contentAlignment = Alignment.TopCenter, + ) { + Row(horizontalArrangement = Arrangement.spacedBy(8.dp)) { + GlassesRecenterAction(stringResource(R.string.glasses_recenter_button), "glasses-recenter", tint, opacity, onClick) + if (onRecenterJoyCons != null) GlassesRecenterAction( + stringResource(R.string.glasses_recenter_joycons_button), "glasses-recenter-joycons", tint, opacity, onRecenterJoyCons) + } + } +} + +@Composable +private fun GlassesRecenterAction(label: String, tag: String, tint: Int, opacity: Int, onClick: () -> Unit) { val source = remember { MutableInteractionSource() } val pressed by source.collectIsPressedAsState() val (fill, line) = padButtonColors(tint, opacity, pressed) val shape = RoundedCornerShape(50) Box( - Modifier.fillMaxSize().windowInsetsPadding(WindowInsets.displayCutout).padding(top = 12.dp), - contentAlignment = Alignment.TopCenter, + contentAlignment = Alignment.Center, + modifier = Modifier + .height(36.dp) + .clip(shape) + .background(fill) + .border(1.5.dp, line, shape) + .clickable(interactionSource = source, indication = null, role = Role.Button, onClick = onClick) + .padding(horizontal = 18.dp) + .testTag(tag), ) { - Box( - contentAlignment = Alignment.Center, - modifier = Modifier - .height(36.dp) - .clip(shape) - .background(fill) - .border(1.5.dp, line, shape) - .clickable(interactionSource = source, indication = null, role = Role.Button, onClick = onClick) - .padding(horizontal = 18.dp) - .testTag("glasses-recenter"), - ) { - Text(stringResource(R.string.glasses_recenter_button), color = line, fontSize = 14.sp) - } + Text(label, color = line, fontSize = 14.sp) } } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/GlassesSetupPanel.kt b/app/src/main/java/com/droiddeck/launcher/ui/GlassesSetupPanel.kt new file mode 100644 index 0000000000..8b2378ae4d --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/GlassesSetupPanel.kt @@ -0,0 +1,38 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.foundation.layout.Arrangement +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.runtime.Composable +import androidx.compose.runtime.LaunchedEffect +import androidx.compose.runtime.getValue +import androidx.compose.runtime.mutableStateOf +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.runtime.setValue +import androidx.compose.ui.Modifier +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.unit.dp +import com.droiddeck.launcher.R +import com.droiddeck.launcher.glasses.GlassesMenuMirror + +@Composable +internal fun GlassesSetupPanel() { + val (glasses, settings) = rememberGlasses() + val host = rememberMenuHost() + val tabs = glassesTabs(glasses) + var selectedTab by rememberSaveable { mutableStateOf(GlassesTab.DISPLAY) } + val tab = selectedTab.takeIf { selected -> tabs.any { it.first == selected } } ?: GlassesTab.DISPLAY + LaunchedEffect(tab, glasses.present, glasses.canControl, glasses.model) { host.open = null } + + Column(Modifier.fillMaxWidth(), verticalArrangement = Arrangement.spacedBy(12.dp)) { + Note(stringResource(R.string.setup_glasses_scope)) + if (!glasses.present && !glasses.hasDisplay && !glasses.canControl) { + Note(stringResource(R.string.setup_glasses_connect)) + } else { + SegmentedTabs(tabs, tab, modifier = Modifier.fillMaxWidth(), + tabModifier = { Modifier.testTag("setup-glasses-tab-$it") }) { selectedTab = it } + GlassesGroups(host, glasses, settings, onRecenter = GlassesMenuMirror::recenter, inSession = false, tab = tab) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/HandCameraUi.kt b/app/src/main/java/com/droiddeck/launcher/ui/HandCameraUi.kt index 58e6bdb135..86b2aa3924 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/HandCameraUi.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/HandCameraUi.kt @@ -79,11 +79,12 @@ import java.util.Locale internal fun HandCameraHost(check: Boolean?, onAskPermission: () -> Unit, onPlay: () -> Unit, onClose: () -> Unit) { if (!HandTracking.supported) return val context = LocalContext.current - val (glasses, _) = rememberGlasses() + val (glasses, tracking) = rememberGlasses() val settings by HandTracking.settings.collectAsState() LaunchedEffect(Unit) { HandTracking.load(context) } var prompted by rememberSaveable { mutableStateOf(false) } - if (!prompted && HandTracking.shouldAsk(settings, glasses.present && glasses.canControl)) { + if (!prompted && !glasses.usesSpatialControllers(tracking) && + HandTracking.shouldAsk(settings, glasses.present && glasses.canControl)) { HandCameraPrompt(settings.sides, onAllow = { side -> prompted = true @@ -168,7 +169,7 @@ internal fun HandCameraRows(host: MenuHost, track: (String) -> Modifier, inSessi HandTracking.refreshPermission(context) denied = !granted } - ToggleRow(host, "hand-camera", stringResource(R.string.hand_camera_setting), stringResource(R.string.hand_camera_setting_hint), + ToggleRow(host, "hand-camera", stringResource(R.string.phone_camera_tracking_setting), stringResource(R.string.hand_camera_setting_hint), s.enabled, chipModifier = track("hand-camera")) { on -> HandTracking.setEnabled(context, on) if (on && !s.permitted) ask.launch(Manifest.permission.CAMERA) diff --git a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt index 2cd1c63b8b..0fb34d6634 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/ModeSettingsDialog.kt @@ -152,13 +152,21 @@ class ModeSettingsActions( /** "2610 r3" from droiddeck-steam-x64's FEX_TAG line (fex-2610-r3), the build the x86-64 client downloads. */ internal fun fexVersionOf(script: String): String? = - Regex("""(?m)^FEX_TAG=fex-(\d+)-r(\d+)\s*$""").find(script)?.let { "${it.groupValues[1]} r${it.groupValues[2]}" } + Regex("""(?m)^FEX_TAG=(fex-\d+-r\d+)\s*$""").find(script)?.let { fexVersionOfTag(it.groupValues[1]) } +/** "2610 r5" from a tag such as fex-2610-r5. */ +internal fun fexVersionOfTag(tag: String): String? = + Regex("""fex-(\d+)-r(\d+)""").matchEntire(tag.trim())?.let { "${it.groupValues[1]} r${it.groupValues[2]}" } + +/** The build installed in the runtime, else the one fex.json names, else the one the launcher pins. */ @Composable private fun x64FexVersion(context: android.content.Context): String? = remember { - runCatching { - context.assets.open("linuxfs/usr/local/bin/droiddeck-steam-x64").bufferedReader().use { fexVersionOf(it.readText()) } - }.getOrNull() + val root = com.droiddeck.launcher.runtime.LinuxRuntime.rootDir(context) + runCatching { java.io.File(root, "usr/local/share/fex-emu/.droiddeck-tag").readText() }.getOrNull()?.let(::fexVersionOfTag) + ?: com.droiddeck.launcher.session.FexCatalog.cached(context)?.tag?.let(::fexVersionOfTag) + ?: runCatching { + context.assets.open("linuxfs/usr/local/bin/droiddeck-steam-x64").bufferedReader().use { fexVersionOf(it.readText()) } + }.getOrNull() } @Composable diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt index 57cd3bdfa6..4d4cdbabad 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SessionOverlay.kt @@ -306,6 +306,10 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont val colors = MaterialTheme.colorScheme val pal = LocalPalette.current val host = rememberMenuHost() + val (glasses, glassesSettings) = rememberGlasses() + val glassesPages = glassesTabs(glasses) + var selectedGlassesTab by rememberSaveable { mutableStateOf(GlassesTab.DISPLAY) } + val glassesTab = selectedGlassesTab.takeIf { key -> glassesPages.any { it.first == key } } ?: GlassesTab.DISPLAY var androidAppsExpanded by rememberSaveable { mutableStateOf(false) } var advancedEffectsExpanded by rememberSaveable { mutableStateOf(false) } var appToChooseDisplay by remember { mutableStateOf(null) } @@ -313,6 +317,10 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont var sheetCoords by remember { mutableStateOf(null) } var stopCoords by remember { mutableStateOf(null) } val pageScroll = remember { SessionDrawerPage.entries.associateWith { ScrollState(0) } } + LaunchedEffect(glassesTab) { + if (page == SessionDrawerPage.GLASSES) host.open = null + pageScroll.getValue(SessionDrawerPage.GLASSES).scrollTo(0) + } val veil by animateFloatAsState(if (open) 1f else 0f, Motion.tw(260), label = "veil") val focus = remember { DrawerFocus() } val inputModeManager = LocalInputModeManager.current @@ -339,7 +347,7 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont if (open && !controllerActive) focusManager.clearFocus(force = true) } var focusedPage by remember { mutableStateOf(page) } - LaunchedEffect(open, page, controllerActive, host.open, appToChooseDisplay, confirmStop) { + LaunchedEffect(open, page, glassesTab, controllerActive, host.open, appToChooseDisplay, confirmStop) { if (!open) { host.open = null confirmStop = false @@ -348,7 +356,11 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont if (host.open != null || appToChooseDisplay != null || confirmStop) return@LaunchedEffect val turned = page != focusedPage focusedPage = page - val first = if (page == SessionDrawerPage.SESSION && a.isHomeApp) "apps" else page.firstControl + val first = when { + page == SessionDrawerPage.GLASSES -> "glasses-tab-$glassesTab" + page == SessionDrawerPage.SESSION && a.isHomeApp -> "apps" + else -> page.firstControl + } if (turned) focus.forget(page) val target = focus.target(page) ?: first repeat(24) { @@ -437,6 +449,10 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont host.open = null; onPageChange(pages.step(page, 1)) } } + if (page == SessionDrawerPage.GLASSES) SegmentedTabs( + glassesPages, glassesTab, modifier = Modifier.fillMaxWidth().padding(top = 8.dp), + tabModifier = { key -> focus.track(page, "glasses-tab-$key").testTag("glasses-tab-$key") }, + ) { selectedGlassesTab = it } Column( modifier = Modifier.weight(1f).fillMaxWidth().verticalScroll(pageScroll.getValue(page)), ) { CompositionLocalProvider(LocalChipMinWidth provides 120.dp) { @@ -538,9 +554,8 @@ internal fun SessionDrawer(open: Boolean, requestedPage: SessionDrawerPage, cont SecondScreenGroup(host, a) { key -> focus.track(page, key) } } SessionDrawerPage.GLASSES -> { - val (g, s) = rememberGlasses() - GlassesGroups(host, g, s, { key -> focus.track(page, key) }, onRecenter = a.onGlassesRecenter, - outputActive = a.glassesOutput, steamVrRunning = a.steamVr == SteamVr.Status.RUNNING, + GlassesGroups(host, glasses, glassesSettings, { key -> focus.track(page, key) }, onRecenter = a.onGlassesRecenter, + tab = glassesTab, outputActive = a.glassesOutput, steamVrRunning = a.steamVr == SteamVr.Status.RUNNING, steamVr = { SteamVrRow(a) }) } SessionDrawerPage.GAMES -> { diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt b/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt index 0a07695b31..8db2cc793b 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SettingsWidgets.kt @@ -761,7 +761,8 @@ fun SettingsPage( } @Composable -fun SegmentedTabs(options: List>, selected: T?, modifier: Modifier = Modifier, onPick: (T) -> Unit) { +fun SegmentedTabs(options: List>, selected: T?, modifier: Modifier = Modifier, + tabModifier: (T) -> Modifier = { Modifier }, onPick: (T) -> Unit) { val colors = MaterialTheme.colorScheme val pal = LocalPalette.current val index = options.indexOfFirst { it.first == selected } @@ -798,7 +799,7 @@ fun SegmentedTabs(options: List>, selected: T?, modifier: Mo val pick = { onPick(value) } Box( contentAlignment = Alignment.Center, - modifier = Modifier.width(segment).fillMaxHeight() + modifier = tabModifier(value).width(segment).fillMaxHeight() .clip(pillShape) .glideBorder(hot, pillShape, if (chosen) pal.onSignal else pal.signal) .semantics { role = Role.Tab; this.selected = chosen } diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SpatialTrackingActivity.kt b/app/src/main/java/com/droiddeck/launcher/ui/SpatialTrackingActivity.kt new file mode 100644 index 0000000000..76539855d9 --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/SpatialTrackingActivity.kt @@ -0,0 +1,258 @@ +package com.droiddeck.launcher.ui + +import android.os.Bundle +import android.os.CancellationSignal +import android.os.ParcelFileDescriptor +import android.print.* +import android.graphics.Bitmap +import android.graphics.pdf.PdfDocument +import android.graphics.Rect +import android.graphics.RectF +import android.graphics.Color +import android.graphics.Paint +import android.text.Layout +import android.text.StaticLayout +import android.text.TextPaint +import androidx.activity.ComponentActivity +import androidx.activity.compose.setContent +import androidx.compose.foundation.Image +import androidx.compose.foundation.layout.* +import androidx.compose.material3.* +import androidx.compose.runtime.* +import androidx.compose.runtime.saveable.rememberSaveable +import androidx.compose.ui.Modifier +import androidx.compose.ui.graphics.asImageBitmap +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.res.stringResource +import androidx.compose.ui.text.style.TextOverflow +import androidx.compose.ui.unit.dp +import com.droiddeck.launcher.R +import com.droiddeck.launcher.core.AppUiPrefs +import com.droiddeck.launcher.glasses.CalibrationDistance +import com.droiddeck.launcher.glasses.Glasses +import com.droiddeck.launcher.glasses.SpatialCalibrationProgress +import com.droiddeck.launcher.glasses.SpatialTracking +import com.droiddeck.launcher.glasses.SpatialTrackingStatus +import com.droiddeck.launcher.glasses.StereoCalibrator +import kotlinx.coroutines.delay +import org.opencv.android.OpenCVLoader +import org.opencv.android.Utils +import org.opencv.core.Mat +import org.opencv.core.Size + +class SpatialTrackingActivity : ComponentActivity() { + override fun attachBaseContext(newBase: android.content.Context) { + super.attachBaseContext(newBase) + com.droiddeck.launcher.core.AppLanguage.applyTo(this, newBase) + } + + override fun onCreate(savedInstanceState: Bundle?) { + super.onCreate(savedInstanceState) + if (!Glasses.state.value.spatialConnected) { finish(); return } + requestedOrientation = com.droiddeck.launcher.session.SessionPrefs.orientation(this) + setContent { + DroidDeckTheme(appScale = AppUiPrefs.scale(this)) { + val glasses by Glasses.state.collectAsState() + if (!glasses.spatialConnected) { + LaunchedEffect(Unit) { SpatialTracking.diagnostics(false); finish() } + return@DroidDeckTheme + } + var preview by remember { mutableStateOf(null) } + var message by remember { mutableStateOf("") } + var progress by remember { mutableStateOf(SpatialCalibrationProgress()) } + var gpu by remember { mutableStateOf(SpatialTracking.gpuEnabled()) } + var lite by remember { mutableStateOf(SpatialTracking.handLiteEnabled()) } + var halfRate by remember { mutableStateOf(SpatialTracking.handHalfRateEnabled()) } + var adaptive by remember { mutableStateOf(SpatialTracking.handAdaptiveInputEnabled()) } + val status by SpatialTracking.status.collectAsState() + LaunchedEffect(Unit) { + while(true) { + SpatialTracking.refreshStatus() + preview = SpatialTracking.diagnosticFrame() + message = SpatialTracking.diagnosticMessage() + progress = SpatialTracking.calibrationProgress() + gpu = SpatialTracking.gpuEnabled() + lite = SpatialTracking.handLiteEnabled() + halfRate = SpatialTracking.handHalfRateEnabled() + adaptive = SpatialTracking.handAdaptiveInputEnabled() + delay(200) + } + } + SpatialSetupScreen(status, progress, preview, message, SpatialSetupActions( + recenter = { SpatialTracking.recenter(false) }, restart = Glasses::restartSpatialTracking, + print = ::printBoard, start = SpatialTracking::calibrationStart, + capture = SpatialTracking::calibrationCapture, solve = SpatialTracking::calibrationSolve, + validate = SpatialTracking::calibrationValidate, gpu = SpatialTracking::setGpu, + lite = SpatialTracking::setHandModel, halfRate = SpatialTracking::setHandHalfRate, + adaptive = SpatialTracking::setHandAdaptiveInput, + saveFrame = SpatialTracking::captureDiagnostic, done = { finish() }), gpu, lite, halfRate, adaptive) + } + } + } + override fun onResume() { + super.onResume() + if (Glasses.state.value.spatialConnected) SpatialTracking.diagnostics(true) else finish() + } + override fun onPause() { SpatialTracking.diagnostics(false);super.onPause() } + private fun printBoard() { + if(!OpenCVLoader.initLocal()) return + val c=StereoCalibrator(this);val mat=Mat() + c.board.generateImage(Size(1500.0,2100.0),mat,0,1) + val bitmap=Bitmap.createBitmap(1500,2100,Bitmap.Config.ARGB_8888) + Utils.matToBitmap(mat,bitmap);mat.release();c.close() + val manager=getSystemService(PRINT_SERVICE) as PrintManager + manager.print(getString(R.string.spatial_print_job),object:PrintDocumentAdapter() { + override fun onLayout(old: PrintAttributes?, new: PrintAttributes, signal: CancellationSignal, callback: LayoutResultCallback, extras: Bundle?) { + callback.onLayoutFinished(PrintDocumentInfo.Builder("droiddeck-charuco.pdf").setPageCount(1).setContentType(PrintDocumentInfo.CONTENT_TYPE_DOCUMENT).build(),true) + } + override fun onWrite(pages: Array, destination: ParcelFileDescriptor, signal: CancellationSignal, callback: WriteResultCallback) { + if(signal.isCanceled) { callback.onWriteCancelled();return } + try { + val pdf=PdfDocument() + try { + val page=pdf.startPage(PdfDocument.PageInfo.Builder(595,842,1).create()) + val scale=72f/25.4f + page.canvas.drawBitmap(bitmap,Rect(0,0,1500,2100),RectF(30*scale,35*scale,180*scale,245*scale),null) + val ink = Paint(Paint.ANTI_ALIAS_FLAG).apply { color = Color.BLACK; textSize = 11f; textAlign = Paint.Align.CENTER } + printText(page.canvas, getString(R.string.spatial_print_title), 12*scale, ink) + ink.textSize = 9f + printText(page.canvas, getString(R.string.spatial_print_scale), 21*scale, ink) + printText(page.canvas, getString(R.string.spatial_print_stationary), 254*scale, ink) + page.canvas.drawLine(55*scale, 270*scale, 155*scale, 270*scale, ink) + page.canvas.drawLine(55*scale, 268*scale, 55*scale, 272*scale, ink) + page.canvas.drawLine(155*scale, 268*scale, 155*scale, 272*scale, ink) + printText(page.canvas, getString(R.string.spatial_print_check), 276*scale, ink) + pdf.finishPage(page) + java.io.FileOutputStream(destination.fileDescriptor).use { pdf.writeTo(it) } + } finally { pdf.close() } + callback.onWriteFinished(arrayOf(PageRange.ALL_PAGES)) + } catch(e: Exception) { callback.onWriteFailed(e.message) } + } + override fun onFinish() { bitmap.recycle() } + },PrintAttributes.Builder().setMediaSize(PrintAttributes.MediaSize.ISO_A4).setColorMode(PrintAttributes.COLOR_MODE_MONOCHROME) + .setMinMargins(PrintAttributes.Margins.NO_MARGINS).build()) + } + + private fun printText(canvas: android.graphics.Canvas, text: String, y: Float, ink: Paint) { + val paint = TextPaint(ink).apply { textAlign = Paint.Align.LEFT } + val layout = StaticLayout.Builder.obtain(text, 0, text.length, paint, 535) + .setAlignment(Layout.Alignment.ALIGN_CENTER).setIncludePad(false).build() + val saved = canvas.save() + canvas.translate(30f, y) + layout.draw(canvas) + canvas.restoreToCount(saved) + } +} + +internal data class SpatialSetupActions( + val recenter: () -> Unit = {}, val restart: () -> Unit = {}, val print: () -> Unit = {}, + val start: () -> Unit = {}, val capture: () -> Unit = {}, val solve: () -> Unit = {}, + val validate: (Float) -> Unit = {}, val gpu: (Boolean) -> Unit = {}, + val lite: (Boolean) -> Unit = {}, val halfRate: (Boolean) -> Unit = {}, + val adaptive: (Boolean) -> Unit = {}, + val saveFrame: () -> Unit = {}, val done: () -> Unit = {}, +) + +@Composable +internal fun SpatialSetupScreen( + status: SpatialTrackingStatus, progress: SpatialCalibrationProgress, preview: Bitmap?, message: String, + actions: SpatialSetupActions, gpu: Boolean = false, lite: Boolean = false, halfRate: Boolean = true, + adaptive: Boolean = true, +) { + val host = rememberMenuHost() + var distance by rememberSaveable { mutableStateOf(CalibrationDistance.INCHES_12) } + var diagnostics by rememberSaveable { mutableStateOf(false) } + var confirmRestart by remember { mutableStateOf(false) } + val ready = status.trackingValid && status.synchronized && !progress.solving && !progress.validating + Surface(Modifier.fillMaxSize().systemBarsPadding(), color = MaterialTheme.colorScheme.background) { + BoxWithConstraints(Modifier.fillMaxSize()) { + CompositionLocalProvider(LocalNarrowPane provides (maxWidth < NarrowPaneWidth)) { + SettingsPage(host, null, actions.done, compactLayout = true, + modifier = Modifier.testTag("spatial-setup-page"), header = { + Text(stringResource(R.string.spatial_title), style = MaterialTheme.typography.titleLarge, + maxLines = 1, overflow = TextOverflow.Ellipsis) + }) { + SettingsGroup(stringResource(R.string.glasses_tracking)) { + SettingsRow(stringResource(R.string.glasses_head_tracking), status.message.ifEmpty { stringResource(R.string.spatial_disabled) }, stacked = true) { + SecondaryButton(if (status.recenterPending) stringResource(R.string.spatial_wait_tracking) else stringResource(R.string.cardboard_recenter_button), + enabled = !status.recenterPending, onClick = actions.recenter) + } + preview?.let { + Image(it.asImageBitmap(), stringResource(R.string.spatial_cameras_description), + Modifier.fillMaxWidth().padding(12.dp).aspectRatio(it.width.toFloat() / it.height)) + } + SettingsRow(stringResource(R.string.spatial_camera_sync), if (status.synchronized) stringResource(R.string.spatial_ready) else + stringResource(R.string.spatial_sync_hint)) {} + } + SettingsGroup(stringResource(R.string.spatial_prepare)) { + ActionRow(stringResource(R.string.spatial_print_actual), stringResource(R.string.spatial_print_hint), + stringResource(R.string.spatial_print), actions.print) + } + SettingsGroup(stringResource(R.string.spatial_capture_group)) { + SettingsRow(stringResource(R.string.spatial_board_stationary), stringResource(R.string.spatial_capture_hint), stacked = true) { + SecondaryButton(stringResource(R.string.spatial_start), enabled = ready, onClick = actions.start) + } + SettingsRow(stringResource(R.string.spatial_views_count, progress.views), when { + !status.trackingValid -> stringResource(R.string.spatial_capture_paused, status.message) + !status.synchronized -> stringResource(R.string.spatial_wait_sync) + !progress.collecting -> progress.captureMessage ?: stringResource(R.string.spatial_start_hint) + else -> progress.captureMessage ?: stringResource(R.string.spatial_views_hint) + }, stacked = true) { + SecondaryButton(if (progress.capturing) stringResource(R.string.spatial_capturing) else stringResource(R.string.spatial_capture), + enabled = ready && progress.collecting && !progress.capturing, onClick = actions.capture) + } + SettingsRow(stringResource(R.string.spatial_alignment), message, stacked = true) { + SecondaryButton(if (progress.solving) stringResource(R.string.spatial_calculating) else stringResource(R.string.spatial_calculate), + enabled = !progress.solving && !progress.validating && progress.views >= 24, onClick = actions.solve) + } + } + SettingsGroup(stringResource(R.string.spatial_distance_group)) { + ChoiceRow(host, "calibration-distance", stringResource(R.string.spatial_distance), stringResource(R.string.spatial_distance_hint), + CalibrationDistance.entries.map { it to stringResource(it.labelRes) }, distance, onPick = { distance = it }) + SettingsRow(stringResource(R.string.spatial_camera_board_distance), progress.validationMessage ?: + stringResource(R.string.spatial_measure_hint, stringResource(distance.labelRes)), stacked = true) { + SecondaryButton(if(progress.validating) stringResource(R.string.spatial_checking_distance) else stringResource(R.string.spatial_validate), + enabled = ready && progress.fitted, onClick = { actions.validate(distance.meters) }) + } + HandCalibrationStatus(status) + SettingsRow(stringResource(R.string.glasses_hands_group), status.handStatus.ifEmpty { stringResource(R.string.spatial_hands_off) }) {} + } + SettingsGroup(stringResource(R.string.spatial_diagnostics)) { + ToggleRow(host, "spatial-diagnostics", stringResource(R.string.spatial_show_diagnostics), stringResource(R.string.spatial_diagnostics_hint), diagnostics) { diagnostics = it } + if (diagnostics) { + SettingsRow(stringResource(R.string.spatial_camera_timing), stringResource(R.string.spatial_timing_values, status.cameraHz, status.frameAgeMs, status.processingMs)) {} + SettingsRow(stringResource(R.string.spatial_hand_input), if (status.cameraHz > 0) + stringResource(R.string.spatial_input_values, status.cameraHz*status.cameraCopyPermille/1000f, status.cameraCopyPermille/10f) + else stringResource(R.string.spatial_wait_timing)) {} + SettingsRow(stringResource(R.string.spatial_frames), stringResource(R.string.spatial_frame_counts, status.frames, status.dropped, status.rateLimitedFrames)) {} + ToggleRow(host, "spatial-gpu", stringResource(R.string.spatial_gpu), stringResource(R.string.spatial_gpu_hint), gpu, onChange = actions.gpu) + ToggleRow(host, "spatial-lite", stringResource(R.string.spatial_lite), stringResource(R.string.spatial_lite_hint), lite, onChange = actions.lite) + ToggleRow(host, "spatial-adaptive-rate", stringResource(R.string.spatial_adaptive), stringResource(R.string.spatial_adaptive_hint), adaptive, onChange = actions.adaptive) + if (!adaptive) ToggleRow(host, "spatial-half-rate", stringResource(R.string.spatial_half_rate), stringResource(R.string.spatial_half_rate_hint), halfRate, onChange = actions.halfRate) + ActionRow(stringResource(R.string.spatial_diagnostic_capture), stringResource(R.string.spatial_diagnostic_capture_hint), stringResource(R.string.spatial_save_frame), actions.saveFrame) + ActionRow(stringResource(R.string.spatial_restart_tracking), stringResource(R.string.spatial_restart_hint), stringResource(R.string.spatial_restart), { confirmRestart = true }) + } + } + Spacer(Modifier.height(16.dp)) + SecondaryButton(stringResource(R.string.setup_check_done), onClick = actions.done) + } + } + } + } + if (confirmRestart) AlertDialog( + onDismissRequest = { confirmRestart = false }, title = { Text(stringResource(R.string.spatial_restart_title)) }, + text = { Text(stringResource(R.string.spatial_restart_confirm)) }, + confirmButton = { TextButton(onClick = { confirmRestart = false; actions.restart() }) { Text(stringResource(R.string.spatial_restart)) } }, + dismissButton = { TextButton(onClick = { confirmRestart = false }) { Text(stringResource(R.string.common_cancel)) } }, + ) +} + +@Composable +internal fun HandCalibrationStatus(status: SpatialTrackingStatus) { + val (label, hint) = when { + status.calibrationSource == "luma-ultra-base" -> R.string.glasses_hands_base to R.string.glasses_hands_base_hint + status.calibrationVerified -> R.string.glasses_hands_calibration_verified to R.string.glasses_hands_ready_hint + else -> R.string.glasses_hands_calibration_required to R.string.glasses_hands_calibration_required_hint + } + SettingsRow(stringResource(label), stringResource(hint)) {} +} diff --git a/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt b/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt index a9ebd88065..5dafd24280 100644 --- a/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt +++ b/app/src/main/java/com/droiddeck/launcher/ui/SteamHome.kt @@ -49,6 +49,7 @@ import androidx.compose.ui.graphics.Color import androidx.compose.ui.graphics.graphicsLayer import androidx.compose.ui.unit.dp import com.droiddeck.launcher.frontend.Library +import com.droiddeck.launcher.glasses.GlassesMenuMirror import androidx.compose.foundation.layout.width import androidx.compose.runtime.LaunchedEffect import androidx.compose.runtime.key @@ -120,7 +121,8 @@ internal fun SteamHome(s: FrontEndState, a: FrontEndActions, modifier: Modifier) modifier = Modifier.fillMaxWidth().testTag("play-steamvr")) { if (enabled) { drop.open = false; a.onPlaySteamVr() } } }, ) { tab -> - GlassesGroups(rememberMenuHost(), glasses, glassesSettings, inSession = false, tab = tab) + GlassesGroups(rememberMenuHost(), glasses, glassesSettings, + onRecenter = GlassesMenuMirror::recenter, inSession = false, tab = tab) } }, onOpen = a.onSteamSettings, onPrimary = a.onPlay, diff --git a/app/src/main/java/com/droiddeck/launcher/ui/TrackingRecoveryView.kt b/app/src/main/java/com/droiddeck/launcher/ui/TrackingRecoveryView.kt new file mode 100644 index 0000000000..44c53a670c --- /dev/null +++ b/app/src/main/java/com/droiddeck/launcher/ui/TrackingRecoveryView.kt @@ -0,0 +1,84 @@ +package com.droiddeck.launcher.ui + +import android.content.Context +import android.graphics.Canvas +import android.graphics.Paint +import android.graphics.Typeface +import android.text.Layout +import android.text.StaticLayout +import android.text.TextPaint +import android.view.View +import androidx.compose.ui.graphics.toArgb +import com.droiddeck.launcher.R +import com.droiddeck.launcher.glasses.TrackingRecovery +import com.droiddeck.launcher.session.SessionPrefs + +internal class TrackingRecoveryView(context: Context) : View(context) { + private var recovery: TrackingRecovery? = null + private var stereo = false + private var palette = Themes.byId(SessionPrefs.theme(context)) + private val paint = Paint(Paint.ANTI_ALIAS_FLAG) + private var blocks = emptyList() + + init { + visibility = GONE + isClickable = true + importantForAccessibility = IMPORTANT_FOR_ACCESSIBILITY_YES + } + + fun update(state: TrackingRecovery?, stereo: Boolean, palette: Palette = Themes.byId(SessionPrefs.theme(context))) { + if (recovery == state && this.stereo == stereo && this.palette == palette) return + recovery = state + this.stereo = stereo + this.palette = palette + visibility = if (state == null) GONE else VISIBLE + blocks = state?.let { + val (title, body, help) = when (it) { + TrackingRecovery.DISCONNECTED -> Triple(R.string.tracking_recovery_disconnected, R.string.tracking_recovery_connect, R.string.tracking_recovery_usb_help) + TrackingRecovery.LOST -> Triple(R.string.tracking_recovery_lost, R.string.tracking_recovery_look, R.string.tracking_recovery_restart_help) + TrackingRecovery.RECENTER -> Triple(R.string.tracking_recovery_recenter, R.string.tracking_recovery_recenter_steps, R.string.tracking_recovery_recenter_help) + TrackingRecovery.STABILIZING -> Triple(R.string.tracking_recovery_stabilizing, R.string.tracking_recovery_hold, R.string.tracking_recovery_automatic) + } + val text = listOf(context.getString(R.string.glasses_head_tracking), context.getString(title), context.getString(body), context.getString(help)) + contentDescription = text.joinToString(". ") + text.mapIndexed { index, value -> + val ink = TextPaint(Paint.ANTI_ALIAS_FLAG).apply { + textSize = floatArrayOf(16f, 38f, 24f, 19f)[index] + color = (when (index) { 0 -> palette.primary; 3 -> palette.onSurfaceVariant; else -> palette.onBackground }).toArgb() + typeface = if (index < 2) Typeface.create("sans-serif-medium", Typeface.NORMAL) else Typeface.create("sans-serif", Typeface.NORMAL) + } + StaticLayout.Builder.obtain(value, 0, value.length, ink, 660) + .setAlignment(Layout.Alignment.ALIGN_NORMAL).setIncludePad(false).setLineSpacing(4f, 1f).build() + } + } ?: emptyList() + if (state == null) contentDescription = null + invalidate() + } + + override fun onDraw(canvas: Canvas) { + super.onDraw(canvas) + if (recovery == null) return + canvas.drawColor(palette.background.toArgb()) + val eyes = if (stereo) 2 else 1 + val eyeWidth = width.toFloat() / eyes + val gaps = floatArrayOf(14f, 24f, 32f, 0f) + val cardHeight = blocks.sumOf { it.height } + gaps.sum() + 80f + val scale = minOf(eyeWidth / 860f, height / (cardHeight + 120f)) + repeat(eyes) { eye -> + val saved = canvas.save() + canvas.clipRect(eye * eyeWidth, 0f, (eye + 1) * eyeWidth, height.toFloat()) + canvas.translate(eye * eyeWidth + (eyeWidth - 740f * scale) / 2f, (height - cardHeight * scale) / 2f) + canvas.scale(scale, scale) + paint.style = Paint.Style.FILL; paint.color = palette.surface.toArgb() + canvas.drawRoundRect(0f, 0f, 740f, cardHeight, 24f, 24f, paint) + paint.style = Paint.Style.STROKE; paint.strokeWidth = 1.5f; paint.color = palette.line.toArgb() + canvas.drawRoundRect(0f, 0f, 740f, cardHeight, 24f, 24f, paint) + canvas.translate(40f, 40f) + blocks.forEachIndexed { index, block -> + block.draw(canvas) + canvas.translate(0f, block.height + gaps[index]) + } + canvas.restoreToCount(saved) + } + } +} diff --git a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java index cbf390098e..e15d809981 100644 --- a/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java +++ b/app/src/main/java/com/droiddeck/launcher/wayland/WaylandCompositor.java @@ -276,6 +276,9 @@ public final class WaylandCompositor { float lensInset, float chroma, boolean mono, float displayHz); public static native void nativeSetCardboardPose(float[] rotation, boolean live); + public static native void nativeSetCardboardSpatialPose(float[] rotation, float[] position, boolean live); + public static native boolean nativeSetSpatialFile(String path); + public static native void nativePublishSpatial(java.nio.ByteBuffer snapshot); public static native void nativeSetCardboardPoseFile(String path); diff --git a/app/src/main/res/values-ar/strings.xml b/app/src/main/res/values-ar/strings.xml index b4c9938ba6..8b5c45a08a 100644 --- a/app/src/main/res/values-ar/strings.xml +++ b/app/src/main/res/values-ar/strings.xml @@ -2466,14 +2466,14 @@ العرض معدل التحديث 3D (جنبًا إلى جنب) - تحصل كل عين على نصفها الخاص من صورة بدقة 3840×1080. إذا انقطعت الصورة، فاضغط مطولًا على زر 2D/3D في النظارة. + تحويل النظارات الذكية إلى وضع ثلاثي الأبعاد جنبًا إلى جنب. يتم التحكم في تتبع الرأس بشكل منفصل. لم يتم تأكيد إشارة 3D. حاول مجددًا بعد عودة صورة 2D. لا توجد صورة: النظارة في وضع لا يستطيع هذا الهاتف إرساله. اضغط مطولًا على زر 2D/3D فيها، أو افصلها ثم أعد توصيلها. معدل تحديث 3D 3D لألعاب الواقع الافتراضي يتحول إلى 3D أثناء تشغيل SteamVR، ثم يعود بعده. - صورة 3D - تلقائي: يملأ SteamVR مجال الرؤية؛ والألعاب الأخرى تظهر كشاشة معلّقة في 3D وتبقى مسطّحة في 2D. + الصورة + يعرض الوضع التلقائي المحتوى المسطح في كلتا العينين ويكتشف SteamVR. اختر وضع اللعب جنبًا إلى جنب لعرض محتوى SBS. تلقائي شاشة افتراضية لعبة جنبًا إلى جنب @@ -2483,20 +2483,20 @@ تُطبَّق هذه الإعدادات عند تفعيل «اللعبة على النظارة» وعرض اللعبة عليها. يُبقي الوضع «تلقائي» لعبة 2D هذه بملء الشاشة. استخدم شاشة افتراضية لضبط عرضها وبُعدها وتتبّع الرأس. استخدام شاشة افتراضية - يملأ SteamVR مجال الرؤية بالكامل. اضبط مجال رؤيته أدناه؛ ولا يُطبَّق عرض الشاشة وبُعدها إلا على الشاشة الافتراضية. + يملأ SteamVR مجال الرؤية. اضبط مجال رؤيته في الواقع الافتراضي؛ ينطبق العرض والمسافة على الشاشة الافتراضية فقط. تملأ ألعاب جنبًا إلى جنب رؤية كل عين. ولا يُطبَّق عرض الشاشة وبُعدها إلا على الشاشة الافتراضية. يُبقي الوضع «تلقائي» لعبة 2D هذه ثابتة أمامك. اختر «شاشة افتراضية» في «العرض» لاستخدام تتبّع الرأس. يُطبَّق تتبّع الرأس على الشاشة الافتراضية أو على لعبة SteamVR قيد التشغيل. - النظارة + الجهاز السطوع مستوى الصوت حجب الشمس يعتّم العدسات الأمامية. - تتبّع الرأس + التتبع تتبّع الرأس تُدير مستشعرات النظارة نفسها الشاشة الافتراضية وSteamVR مع حركة رأسك. إعادة توسيط العرض - إعادة التوسيط + إعادة توسيط الشاشة مجال رؤية SteamVR القيمة الأقل تقرّب SteamVR وتملأ النظارة؛ والأعلى تُظهر المزيد مما حولك. جارٍ اللعب على %1$s @@ -2517,8 +2517,8 @@ هل تريد إزالة المعايرة المحفوظة واستعادة الإعدادات الافتراضية للطراز؟ أعد توسيط العرض بعد ارتداء النظارة مجددًا. إعادة ضبط تتبّع اليدين - تتبّع يديك باستخدام الكاميرا؟ - يمكن للكاميرا رؤية يديك. عند عدم توصيل أي وحدة تحكم، تصبح يداك المجردتان هما يدا VR: اضغط الإبهام والسبابة معًا للنقر، وأغلق يدك للإمساك، ووجّه راحة يدك نحوك واضغط بإصبعيك لفتح القائمة. مع Joy-Con، تضعها الكاميرا حيث توجد يداك فعلًا. تُعالَج الصور على هذا الجهاز ولا تُحفظ أو تُرسَل أبدًا. + تتبع اليدين أو وحدات تحكم Joy-Con باستخدام كاميرا الهاتف؟ + عند عدم توصيل وحدة تحكم، تتتبع كاميرا الهاتف يديك في الواقع الافتراضي: اضغط بإبهامك وسبابتك للنقر، وأغلق يدك للإمساك، وأدر راحة يدك نحوك واضغط لفتح القائمة. عند توصيل وحدات تحكم Joy-Con، تتتبع الكاميرا موضعها بينما توفر وحدات التحكم إمكانية الدوران وإدخال الأزرار. تتم معالجة الصور على هذا الجهاز ولا يتم حفظها أو إرسالها. الكاميرا الخلفية مُوصى بها. عادةً أوضح وأوسع. الكاميرا الأمامية @@ -2526,7 +2526,7 @@ استخدام الكاميرا ليس الآن تتبّع اليدين بالكاميرا - عند عدم توصيل أي وحدة تحكم، تصبح يداك هما يدا VR: اضغط بإصبعيك للنقر، ووجّه راحة يدك نحوك واضغط لفتح القائمة. مع Joy-Con، تضعها حيث تراها الكاميرا. تبقى الصور على هذا الجهاز. + استخدم كاميرا الهاتف لإيماءات اليد المجردة أو لتحديد موضع وحدات تحكم Joy-Con المقترنة في الواقع الافتراضي. توفر وحدات تحكم Joy-Con التحكم في الدوران والأزرار. يتوقف التتبع مؤقتًا بينما تتعقب النظارات الذكية يديك أو وحدات تحكم Joy-Con. تتم معالجة الصور على هذا الجهاز فقط. الكاميرا الوصول إلى الكاميرا اسمح بالوصول إلى الكاميرا حتى يبدأ تتبّع اليدين. @@ -2780,4 +2780,208 @@ جارٍ تحويل %1$s لـ Steam. أبقِ DroidDeck مفتوحًا. لا يستطيع هذا الجهاز فك ترميز هذا الفيديو. تعذّر استيراد الفيديو + كاميرات Luma Ultra - تجريبية + تتبع موضع Joy-Con + استخدم كاميرات النظارات الذكية لتحديد موضع وحدات تحكم Joy-Con المقترنة. يتم التحكم في الدوران والأزرار من خلال وحدات تحكم Joy-Con. يتم تقدير الموضع عندما تكون معصميك مخفية. يحل هذا محل وحدات التحكم التي يتم تشغيلها باليدين ويوقف تتبع كاميرا الهاتف مؤقتًا. وجّه وحدات تحكم Joy-Con للأمام عند توصيل مركز التتبع أو إعادة ضبطه. + فعّل تتبع الموضع أولًا. يتطلب ذلك وحدات تحكم Joy-Con تدعم الحركة على نظام Android 12 أو أحدث. مُعطّل افتراضيًا. + النظارات الذكية + تتم مشاركة إعدادات العرض وتتبع الرأس بين قوائم DroidDeck والألعاب وجلسات سطح المكتب. + وصّل النظارات الذكية لتغيير إعدادات العرض والتتبع. يتم الاحتفاظ بإعداداتك المحفوظة عند فصلها. + الواقع الافتراضي + وضع العرض + إخراج ثنائي الأبعاد + إخراج ثلاثي الأبعاد + الصورة والشاشة الافتراضية + الموضع ومستوى الأرضية + تتبع اليدين - تجريبي + حالة التتبع + دقة ثنائية الأبعاد + دقة ثلاثية الأبعاد + دقة الواقع الافتراضي + تلقائي + نفس دقة العرض ثنائي/ثلاثي الأبعاد + دقة الإخراج لكل عين. + تفعيل وضع الألعاب على النظارات الذكية لاختيار وضع 30 هرتز الأصلي للشاشة. + شاشة افتراضية 3DoF + تثبيت الألعاب المسطحة أمامك لتتمكن من النظر حولك. يُمكّن هذا الخيار وضع الألعاب على النظارات الذكية دون الحاجة إلى التحويل إلى وضع ثلاثي الأبعاد. + يتم تحديث العرض والمسافة للشاشة الافتراضية المُتتبعة لقوائم DroidDeck والألعاب وجلسات سطح المكتب فورًا. + يشمل تتبع الحركة دوران الرأس في SteamVR. لتتبع الدوران فقط، أوقف تتبع الحركة. + يتحكم في حركة الرأس على الشاشة الافتراضية. يشمل تتبع الحركة دوران الرأس في SteamVR. + إجراءات سريعة + انظر إلى المكان الذي تريد وضع الشاشة فيه، ثم أعد ضبط مركز التتبع لتحديد ارتفاعه واتجاهه. + إعادة توسيط Joy-Con + كاميرا الهاتف - تجريبية + تتبع اليدين أو وحدات تحكم Joy-Con + شاشة افتراضية 6DoF + تتبع الموقع - تجريبي + الحركة الجسدية في الواقع الافتراضي وحول الشاشات الافتراضية. قد يستغرق إعادة تشغيل التتبع لحظة. + ارتفاع العين الحالي عن الأرض + ضبط مستوى الأرض من الارتفاع الحالي + ضبط مستوى الأرض + إعداد الكاميرا المجسمة وتشخيصها + تحقق من معايرة الكاميرا وتتبع اليدين قبل اللعب. + فتح الإعدادات + وحدات التحكم التي يتم تشغيلها باليدين + استخدم كاميرات النظارات الذكية للتصويب بيديك، وقرّب للنقر، وأغلق يدك للإمساك في الواقع الافتراضي. تتحرك عصي التحكم وتدور. يحل هذا محل تتبع موقع Joy-Con. قد يحدث تأخير أو فقدان للتتبع أثناء اللعب. + فعّل وحدات التحكم التي يتم تشغيلها باليدين تحت كاميرات Luma Ultra في التتبع. اعرض اليدين المفتوحتين أولاً. + معايرة Luma Ultra المشتركة + استخدام قاعدة Luma Ultra المشتركة. قم بمعايرة نظارتك الذكية للتحقق من دقتها. + تم التحقق من صحة المعايرة المقاسة + يلزم التحقق + تصبح وحدات التحكم التي يتم تشغيلها باليدين متاحة بعد اجتياز فحص المسافة المقاسة. + فقد التتبع + انظر حولك ببطء في غرفة مضاءة جيدًا.\nحافظ على خلو مجال رؤية كاميرات التتبع، ووجه نظرك نحو الأثاث أو أي تفاصيل مرئية أخرى. + لا تزال عالقة؟ على هاتفك: النظارات الذكية → التتبع → فتح الإعداد → إظهار التشخيص → إعادة تشغيل التتبع. + تم فصل النظارات الذكية + تحقق من اتصال USB وأعد توصيل النظارات الذكية.\nاقبل مطالبة الوصول عبر USB على هاتفك إذا ظهرت. + بمجرد الاتصال، انظر حولك ببطء في غرفة مضاءة جيدًا لاستعادة التتبع. + يلزم إعادة التوسيط + عاد التتبع إلى موقع جديد.\nانظر للأمام، ثم انقر على \"إعادة ضبط مركز التتبع\" على هاتفك. + يمكنك أيضًا العثور على \"إعادة ضبط مركز التتبع\" في النظارات الذكية ← التتبع ← فتح الإعدادات. سيتم الاحتفاظ بمعايرة الكاميرا المحفوظة. + ابقَ ثابتًا للحظة + جارٍ إعادة ضبط مركز التتبع.\nحافظ على ثبات النظارات الذكية أثناء استقرار التتبع. + يتم إغلاق هذه الشاشة تلقائيًا عندما يكون تتبع الرأس جاهزًا. + التصويب المستقر بالأيدي + صوب من كتفك إلى راحة يدك. قم بإيقاف التشغيل للدوران الذي يتم التحكم فيه بالمعصم. + الإعداد المكاني + في انتظار التتبع... + كاميرات التتبع اليسرى واليمنى + مزامنة الكاميرا + جاهز + في انتظار اصطفاف الكاميرا وتتبع الرأس. حافظ على النظارات الذكية متصلة. + 1. قم بإعداد هدف المعايرة + الطباعة بالحجم الفعلي + يجب أن يبلغ قياس كل مربع 30 مم (1.181 بوصة). قم بتركيب الورقة بشكل مسطح على سطح صلب في منطقة مضاءة جيدًا. + طباعة لوحة المعايرة + 2. التقط مناظر مختلفة + حافظ على هدف المعايرة ثابتًا + قم بتحريك النظارة الذكية بشكل أقرب وأبعد وعلى الجانب. اقلبهم إلى اليسار/اليمين، وزاويتهم لأعلى/لأسفل، وقم بإمالتهم جانبًا. احتفظ بهدف المعايرة في كلتا الكاميرتين وتوقف لفترة وجيزة قبل كل التقاط. + ابدأ معايرة جديدة + في انتظار مزامنة الكاميرا. + ابدأ معايرة جديدة لتجميع طرق العرض. + اجعل هدف المعايرة مرئيًا في كلا المعاينتين. التقط ما لا يقل عن 24 منظرًا حادًا من زوايا مختلفة. + الالتقاط... + التقط عرض هدف المعايرة + حساب محاذاة الكاميرا + حساب… + حساب المعايرة + 3. التحقق من المسافة + المسافة المقاسة + ابدأ بـ 12 بوصة أو 30 سم حتى يسهل اكتشاف العلامات المطبوعة. اختر القياس الدقيق الذي ستستخدمه. + الكاميرا اليسرى لمركز هدف المعايرة + فحص المسافة... + التحقق من المسافة + التشخيص + عرض التشخيص + توقيت الكاميرا وأدوات استرداد التتبع. + توقيت الكاميرا + مدخلات من تتبع الأيدي + انتظار توقيت الكاميرا. + صور الكاميرا + كشف GPU للأيدي + المعالج CPU هو الخيار الافتراضي. استخدام GPU تجريبي وقد يؤدي إلى إعادة تشغيل SteamVR. يُعاد ضبط هذا الخيار عند إعادة تشغيل التتبع. + الكشف البسيط عن نماذج الأيدي + استخدم كاشف راحة اليد Lite ونقاط مفتاح Lite الموجودة على اليدين. تحقق من دقة التصويب والقرص والاستيلاء. إعادة التعيين عند إعادة تشغيل التتبع. + تردد الإدخال التلقائي لتتبع العقارب + اضبط الإدخال حسب سرعة المعالجة. إعادة التعيين عند إعادة تشغيل التتبع. + الحد من تردد الإدخال لتتبع العقارب + استخدم نصف صور الكاميرا. قم بإيقاف التشغيل لمقارنة الحد الأقصى للتردد. إعادة التعيين عند إعادة تشغيل التتبع. + التقاط التشخيص + احفظ زوجًا واحدًا من صور الاستريو محليًا. يتم حفظ الصور فقط عند الطلب. + حفظ صورة الكاميرا + إعادة تشغيل التتبع + يُستخدم في حالة عدم استعادة التتبع في منطقة جيدة الإضاءة. تتطلب إعادة التشغيل أصل تتبع جديد. + إعادة التشغيل + إعادة تشغيل التتبع؟ + ستُفقد مشاهد المعايرة غير المحفوظة. حافظ على ثبات النظارات الذكية بعد ذلك، وأعد ضبط مركز التتبع عند استعادة التتبع. + %1$d / تم التقاط 24 مشاهدة + تم إيقاف الالتقاط مؤقتًا: %1$s + قِس %1$s. أظهر لوحة المعايرة كاملة في معاينتي الكاميرا، ثم ابقَ ثابتًا. + %1$.1f هرتز • عمر الصورة %2$.1f مللي ثانية • المعالجة %3$.1f مللي ثانية + حد الإدخال %1$.1f هرتز • %2$.0f%% لصور الكاميرا. يستمر تتبع الرأس بأقصى تردد. + تمت معالجة %1$d • تم إسقاط %2$d • تم تخطي %3$d بواسطة حد الإدخال + DroidDeck ChArUco 30 mm + DroidDeck - معايرة Luma Ultra + الطباعة بحجم 100% / الحجم الفعلي. كل مربع: 30 ملم (1.181 بوصة). + حافظ على هدف المعايرة مسطحًا وثابتًا؛ حرك النظارات الذكية بين اللقطات. + فحص المقياس: 100 ملم (3.937 بوصة) بين علامات التجزئة + 12 بوصة (30.48 سم) + 30 سم (11.81 بوصة) + 20 بوصة (50.8 سم) + 50 سم (19.69 بوصة) + معطل + في انتظار التتبع المستقر + منقطع + تم إيقاف تشغيل وحدات التحكم التي يتم تشغيلها بالأيدي العارية + تم إيقاف التتبع الموضعي أو تم فصل النظارات الذكية + تم طلب إعادة ضبط مركز التتبع - حافظ على ثباتك أثناء استقرار التتبع. + تم فقدان التتبع - واجه منطقة مضاءة جيدًا بتفاصيل مرئية + تم تغيير نقطة الأصل للتتبع - انقر على \"إعادة ضبط مركز التتبع\"، ثم حافظ على ثباتك. + 6DoF نشط + قم بتوصيل Luma Ultra وتمكين التتبع الموضعي. + تم التحقق من المعايرة لهذا الاتصال. + تم التحقق من المعايرة وحفظها. + في انتظار كاميرات الاستريو + انتظار تتبع الأيدي + أبقِ هدف المعايرة 5 × 7 ثابتًا. التقط أكثر من 24 مشاهدة أثناء تحريك النظارات الذكية وتدويرها. + بانتظار صورة الكاميرا التالية. أبقِ النظارات ثابتة. + جارٍ فحص صورة الكاميرا التالية. أبقِ لوحة المعايرة كاملة في مجال الرؤية ولا تتحرك. + ابدأ المعايرة أولاً + لم تصل أي صورة جديدة للكاميرا. تحقق من اتصال النظارات الذكية ومعاينات الكاميرا، ثم أعد المحاولة. + إعادة ضبط ساعة الكاميرا + تم تغيير نظام إحداثيات التتبع. تم حفظ مشاهدك لإعادة الحساب. أعد ضبط مركز التتبع، ثم ابدأ مجموعة جديدة لالتقاط المزيد من المشاهد. + تم تحميل معايرة الجهاز + تم تحميل معايرة قاعدة Luma Ultra + المعايرة مطلوبة + اضغط على بدء المعايرة الجديدة أولاً. + مركز إعادة ضبط التتبع ينتظر استقرار التتبع. حافظ على ثباتك للحظة. + تم تغيير التتبع. انقر على \"إعادة ضبط مركز التتبع\" مرة واحدة، ثم ثبّت الكاميرا قبل التقاط الصورة. + رُفض الالتقاط: لم يكن تتبع الرأس متزامنًا أو تغيّر أثناء الالتقاط. ابقَ ثابتًا وحاول مرة أخرى. + احسب محاذاة الكاميرا قبل التحقق من المسافة. + فشلت معالجة الكاميرا + تم تغيير تتبع الرأس أثناء اكتشاف الأيدي + في انتظار تزامن الكاميرا والرأس + لم يتم اكتشاف معصمين. احتفظ بمقابض وحدة التحكم Joy-Con أمام النظارات الذكية + لم يتم اكتشاف أي يد. أظهر راحتي يديك مفتوحتين أمام النظارات. + يمكن رؤية المعصمين في كاميرا واحدة فقط؛ احتفظ بمقابض وحدة التحكم الخاصة بك في العرض المشترك + تظهر اليدان في كاميرا واحدة فقط؛ أبقِ راحتي يديك في مجال الرؤية المشترك. + كلتا الكاميرتين ترى الأيدي، لكن مطابقة اليسار/اليمين غامضة + تم اكتشاف اليدين، لكن قياس العمق بالكاميرتين غير متسق. + تم رفض وضع المعصم عن طريق فحص الاستريو أو الحركة + تم اكتشاف نقاط بالكاميرتين، لكن شكل راحة اليد غير متسق. + المعايرة الكاملة وفحص المسافة لتمكين اليدين + جارٍ انتظار استقرار تتبع الرأس؛ أعد ضبط مركز التتبع إذا طُلب منك ذلك. + المراقبة بالكاميرات قديمة جدًا؛ في انتظار زوج جديد + تناسب %1$.2f بكسل. قم بقياس المسافة التي حددتها من الكاميرا اليسرى إلى مركز هدف المعايرة، ثم قم بالتحقق من صحتها. + OpenCV غير متاح: %1$s + تمت استعادة %1$d من المشاهدات المحفوظة. قم بحساب المعايرة لإعادة المحاولة، أو ابدأ مجموعة جديدة لالتقاط المزيد. + ملتقطة %1$d / 24 مشاهدة. حافظ على هدف المعايرة ثابتًا؛ حرك النظارات الذكية للعرض التالي. + رُفض الالتقاط: تظهر %1$d / 12 زاوية مطلوبة في كلتا الكاميرتين. أظهر جزءًا أكبر من لوحة المعايرة، وابقَ ثابتًا ثم حاول مرة أخرى. + تعذر إنهاء فحص المسافة: %1$s. حاول ثانية. + تعذر اكتشاف اليدين: %1$s. غيّر خيار CPU/GPU أو أوقف التحكم باليدين ثم أعد تشغيله للمحاولة مجددًا. + تجاوز كشف الأيدي %1$d مللي ثانية؛ تم تجاهل الملاحظة + %1$d / 2 وضعية معصم Joy-Con يتم قياسها بواسطة الاستريو + تتبع راحتي اليد: %1$d / 2؛ جاهزية ضم الأصابع: %2$d؛ جاهزية القبض: %3$d + تم حفظ الالتقاط التشخيصي في %1$s + توقف تتبع الأيدي: %1$s + استريو %1$d×%2$d؛ %3$s + يختلف تتبع الرأس ولوحة المعايرة بمقدار %1$s (الحد الأقصى 5 سم / 2 بوصة). أبقِ اللوحة ثابتة وانتظر استقرار التتبع قبل بدء مجموعة جديدة. أدِر النظارات وأمِلها برفق، وتوقف قبل كل التقاط. + التقط ما لا يقل عن 24 منظرًا متنوعًا لهدف المعايرة الثابت. + قم بتدوير النظارات الذكية يمينًا ويسارًا، وإمالتها لأعلى ولأسفل؛ لا يمكن للحركة بدون دوران معايرة محاذاة الكاميرا. + خط الأساس غير المعقول للكاميرا + حرك رأسك في اتجاهات أكثر تنوعًا. + تدوير الكاميرا للرأس غير صالح + محاذاة الكاميرا مع الرأس غير متناسقة. + تعذر إنهاء المعايرة. %1$s تم حفظ مشاهداتك الملتقطة. + خطأ إعادة الإسقاط المعلق %1$.2f بكسل يتجاوز 2 بكسل. إعادة المعايرة. + تم اكتشاف %1$d / 24 زاوية من نمط المعايرة في كلتا الكاميرتين. أبقِ اللوحة كاملة في مجال الرؤية ولا تتحرك. إذا كانت ظاهرة بالفعل، اختر 12 بوصة أو 30 سم وقِس هذه المسافة الأقرب قبل إعادة المحاولة. + هدف المعايرة مرئي، ولكن لا يمكن قياس عمقه بشكل موثوق. أمسك النظارات الذكية بثبات وحافظ على هدف المعايرة مسطحًا ومضاء جيدًا، ثم أعد المحاولة. + قياس الكاميرا غير صالح. ابقَ ثابتًا وحاول مرة أخرى. + تم اجتياز فحص المسافة. + أعد فحص المسافة من الكاميرا اليسرى إلى مركز هدف المعايرة، ثم أعد المحاولة. + قياس الكاميرات %1$s؛ المسافة المختارة %2$s. %3$s + انتظر معاينات الكاميرا قبل بدء المعايرة. + يمكن إعادة حساب المشاهدات المحفوظة. ابدأ معايرة جديدة لالتقاطها في نظام إحداثيات التتبع الحالي. + المجموع الاختباري لنموذج تتبع اليدين غير مطابق + تعذر تحميل OpenCV diff --git a/app/src/main/res/values-b+es+419/strings.xml b/app/src/main/res/values-b+es+419/strings.xml index d4fcefe800..729f2aa74e 100644 --- a/app/src/main/res/values-b+es+419/strings.xml +++ b/app/src/main/res/values-b+es+419/strings.xml @@ -976,7 +976,7 @@ Presiona Select para abrir el menú de Steam Joy-Con como controles de RV Mientras SteamVR está activo, cada Joy-Con es una mano. Apúntalo al frente y mantén Home o Captura para recentrarlo. - La cámara puede ver tus manos. Sin ningún control conectado, tus manos desnudas pasan a ser las manos de RV: junta el pulgar y el índice para hacer clic, cierra la mano para agarrar y, para abrir el menú, gira la palma hacia ti y junta los dedos. Con Joy-Con, los coloca donde están de verdad tus manos. Las imágenes se procesan en este dispositivo y nunca se guardan ni se envían. + Sin ningún mando conectado, la cámara del teléfono rastrea tus manos en realidad virtual: pellizca con el pulgar y el índice para hacer clic, cierra la mano para agarrar y gira la palma hacia ti y pellizca para abrir el menú. Con los mandos Joy-Con emparejados, la cámara rastrea su posición mientras los mandos Joy-Con proporcionan la rotación y las entradas de los botones. Las imágenes se procesan en este dispositivo y nunca se guardan ni se envían. Cámara trasera Recomendada. Suele ser más nítida y amplia. Cámara frontal @@ -984,7 +984,7 @@ Usar cámara Ahora no Seguimiento de manos por cámara - Sin ningún control conectado, tus manos pasan a ser las manos de RV: junta los dedos para hacer clic y, con la palma hacia ti, júntalos para abrir el menú. Con Joy-Con, los coloca donde la cámara los ve. Las imágenes se quedan en este dispositivo. + Usa la cámara del teléfono para gestos con las manos desnudas o para posicionar los mandos Joy-Con emparejados en realidad virtual. Los mandos Joy-Con proporcionan la rotación y las pulsaciones de los botones. Se pausa mientras las gafas inteligentes rastrean tus manos o los mandos Joy-Con. Las imágenes se procesan solo en este dispositivo. Cámara Acceso a la cámara Permite el acceso a la cámara para que el seguimiento de manos pueda empezar. @@ -2414,14 +2414,14 @@ Pantalla Frecuencia de actualización 3D (lado a lado) - Cada ojo recibe su propia mitad de una imagen de 3840×1080. Si la imagen se pierde, mantén presionado el botón 2D/3D de las gafas. + Cambia las gafas inteligentes a 3D lado a lado. El seguimiento de la cabeza se controla por separado. No se ha confirmado la señal 3D. Inténtalo de nuevo cuando vuelva la imagen 2D. Sin imagen: las gafas están en un modo que este teléfono no puede enviar. Mantén presionado su botón 2D/3D o desconéctalas y vuelve a conectarlas. Frecuencia en 3D 3D para juegos de RV Cambia a 3D mientras SteamVR está en marcha, y vuelve después. - Imagen 3D - Automático: SteamVR llena la vista; los demás juegos flotan como una pantalla en 3D y se ven planos en 2D. + Imagen + Muestra automáticamente contenido plano en ambos ojos y detecta SteamVR. Seleccione Juego lado a lado para contenido SBS. Automático Pantalla virtual Juego lado a lado @@ -2431,20 +2431,20 @@ Estos ajustes se aplican mientras Juego en las gafas está activado y el juego se muestra allí. Automático mantiene este juego 2D a pantalla completa. Usa una pantalla virtual para ajustar su ancho, distancia y seguimiento de cabeza. Usar pantalla virtual - SteamVR llena la vista. Ajusta su campo de visión abajo; el ancho y la distancia solo se aplican a una pantalla virtual. + SteamVR llena la vista. Ajuste su campo de visión en RV; el ancho y la distancia solo se aplican a una pantalla virtual. Los juegos lado a lado llenan cada ojo. El ancho y la distancia solo se aplican a una pantalla virtual. Automático mantiene este juego 2D fijo en la vista. Elige Pantalla virtual en la sección Pantalla para usar el seguimiento de cabeza. El seguimiento de cabeza se aplica a una pantalla virtual o a un juego de SteamVR en marcha. - Gafas + Dispositivo Brillo Volumen Bloqueo solar Oscurece las lentes frontales. - Seguimiento de cabeza + Seguimiento Seguimiento de cabeza Los sensores de las gafas giran la pantalla virtual y SteamVR con tu cabeza. Recentrar la vista - Recentrar + Volver a centrar la pantalla Campo de visión de SteamVR Más bajo acerca SteamVR y llena las gafas; más alto muestra más a tu alrededor. Jugando en %1$s @@ -2465,7 +2465,7 @@ ¿Quitar la calibración guardada y restaurar los valores predeterminados del modelo? Recentra después de volver a ponerte las gafas. Restablecer Seguimiento de manos - ¿Seguir tus manos con la cámara? + ¿Rastrear las manos o los mandos Joy-Con con la cámara del teléfono? Posición de la imagen Arriba Abajo @@ -2657,4 +2657,208 @@ Convirtiendo %1$s para Steam. Mantén DroidDeck abierto. Este dispositivo no puede decodificar ese video. No se pudo importar ese video + Cámaras Luma Ultra — Experimental + Seguimiento de posición de los Joy-Con + Usa las cámaras de las gafas inteligentes para posicionar tus mandos Joy-Con emparejados. La rotación y las pulsaciones de los botones provienen de los mandos Joy-Con. La posición se estima cuando tus muñecas están ocultas. Reemplaza los mandos operados con las manos desnudas y pausa el seguimiento de la cámara del teléfono. Apunta los mandos Joy-Con hacia adelante al conectar o restablecer el centro de seguimiento. + Activa primero el seguimiento de posición. Requiere mandos Joy-Con compatibles con movimiento en Android 12 o posterior. Desactivado por defecto. + Gafas inteligentes + La configuración de pantalla y seguimiento de cabeza se comparte entre los menús de DroidDeck, los juegos y las sesiones de escritorio. + Conecta las gafas inteligentes para cambiar su configuración de pantalla y seguimiento. Tu configuración guardada se conserva al desconectarlas. + RV + Modo de visualización + Salida 2D + Salida 3D + Imagen y pantalla virtual + Posición y nivel del suelo + Seguimiento de manos — Experimental + Estado del seguimiento + Resolución 2D + Resolución 3D + Resolución RV + Automático + Igual que 2D/3D + Resolución de salida por ojo. + Habilita el juego en gafas inteligentes para seleccionar el modo nativo de 30 Hz de la pantalla. + Pantalla virtual 3DoF + Ancla los juegos planos frente a ti para que puedas mirar a tu alrededor. Habilita el juego en gafas inteligentes sin cambiar a 3D. + El ancho y la distancia actualizan la pantalla virtual rastreada para los menús, juegos y sesiones de escritorio de DroidDeck de forma inmediata. + El seguimiento posicional incluye la rotación de la cabeza en SteamVR. Para el seguimiento solo de rotación, desactive el seguimiento posicional. + Controla el movimiento de la cabeza en la pantalla virtual. El seguimiento posicional incluye la rotación de la cabeza en SteamVR. + Acciones rápidas + Mira hacia donde quieras que esté la pantalla y luego restablece el centro de seguimiento para ajustar su altura y dirección. + Volver a centrar los Joy-Con + Cámara del teléfono — Experimental + Rastrear manos o mandos Joy-Con + Pantalla virtual 6DoF + Seguimiento posicional — experimental + Movimiento físico en RV y alrededor de pantallas virtuales. Reiniciar el seguimiento tarda un momento. + Altura actual de los ojos sobre el suelo + Establecer el nivel del suelo desde la altura actual + Establecer el nivel del suelo + Configuración y diagnóstico de la cámara estéreo + Comprobar la calibración de la cámara y el seguimiento de las manos antes de jugar. + Abrir configuración + Mandos operados con las manos desnudas + Usar las cámaras de las gafas inteligentes para apuntar con las manos, pellizcar para hacer clic y cerrar la mano para agarrar en RV. Los joysticks del mando se mueven y giran. Sustituye el seguimiento de posición de los Joy-Con. Puede haber retrasos o pérdida de seguimiento durante los juegos. + Habilitar el uso de mandos operados con las manos desnudas bajo las cámaras Luma Ultra en Seguimiento. Mostrar primero las manos abiertas. + Calibración compartida de Luma Ultra + Usar la base compartida de Luma Ultra. Calibra tus gafas inteligentes para verificar su precisión. + Calibración medida verificada + Validación requerida + Los controladores operados con las manos desnudas estarán disponibles después de que la verificación de distancia medida sea exitosa. + Seguimiento perdido + Mira a tu alrededor lentamente en una habitación bien iluminada.\nMantén las cámaras de seguimiento despejadas y enfoca los muebles u otros detalles visibles. + ¿Sigues estancado? En su teléfono: gafas inteligentes → Seguimiento → Abrir configuración → Mostrar diagnóstico → Reiniciar seguimiento. + Gafas inteligentes desconectadas + Verifique la conexión USB y vuelva a conectar las gafas inteligentes.\nAcepte el mensaje de acceso USB en su teléfono si aparece. + Una vez conectado, mire lentamente a su alrededor en una habitación bien iluminada para restablecer el seguimiento. + Es necesario volver a centrar + El seguimiento ha vuelto a una nueva posición.\nMira hacia adelante y luego toca \"Restablecer centro de seguimiento\" en tu teléfono. + También puedes encontrar la opción para restablecer el centro de seguimiento en las gafas inteligentes → Seguimiento → Abrir configuración. Se conserva la calibración de la cámara guardada. + Quédate quieto por un momento + El restablecimiento del centro de seguimiento está en curso.\nMantén las gafas inteligentes estables mientras se estabiliza el seguimiento. + Esta pantalla se cierra automáticamente cuando el seguimiento de la cabeza está listo. + Apuntar estabilizado con las manos + Apunta desde tu hombro a través de tu palma. Apague para rotación controlada por la muñeca. + Configuración espacial + Esperando seguimiento… + Cámaras de seguimiento izquierda y derecha + Sincronización de cámaras + Listo + Esperando que la cámara y el seguimiento de la cabeza se alineen. Mantenga las gafas inteligentes conectadas. + 1. Prepare el objetivo de calibración + Imprimir en tamaño real + Cada cuadrado debe medir 30 mm (1.181 in). Monte la hoja plana sobre una superficie rígida en un área bien iluminada. + Imprimir patrón de calibración + 2. Captura diferentes vistas + Mantener estacionario el objetivo de calibración + Acerque, aleje y lateralmente las gafas inteligentes. Gírelos hacia la izquierda/derecha, inclínelos hacia arriba/abajo e inclínelos hacia los lados. Mantenga el objetivo de calibración en ambas cámaras y haga una pausa breve antes de cada captura. + Iniciar nueva calibración + Esperando sincronización de cámaras. + Inicie una nueva calibración para recopilar vistas. + Mantenga el objetivo de calibración visible en ambas vistas previas. Capture al menos 24 vistas nítidas desde diferentes ángulos. + Capturando… + Capturar vista del objetivo de calibración + Calcular la alineación de la cámara + Calculando… + Calcular calibración + 3. Verifique la distancia + Distancia medida + Comience con 12 pulgadas o 30 cm para que los marcadores impresos sean más fáciles de detectar. Elige la medida exacta que utilizarás. + Cámara izquierda al centro del objetivo de calibración + Comprobando la distancia... + Validar distancia + Diagnóstico + Mostrar diagnóstico + Herramientas de recuperación de seguimiento y sincronización de cámaras. + Sincronización de la cámara + Entrada del seguimiento de manos + Esperando la sincronización de la cámara. + Imágenes de la cámara + Detección de manos por GPU + CPU es el valor predeterminado. La GPU es experimental y puede hacer que SteamVR se reinicie. Esta opción se restablece cuando se reinicia el seguimiento. + Detección Lite de modelos de manos. + Utilice el detector de palma Lite y los puntos clave Lite en las manos. Compruebe la precisión de apuntar, pellizcar y agarrar. Se reinicia cuando se reinicia el seguimiento. + Frecuencia de entrada automática para seguimiento de manos + Ajusta la entrada a la velocidad de procesamiento. Se reinicia cuando se reinicia el seguimiento. + Limitar la frecuencia de entrada para el seguimiento de manos + Utilice la mitad de las imágenes de la cámara. Apague para comparar la frecuencia máxima. Se reinicia cuando se reinicia el seguimiento. + Captura de diagnóstico + Guarde un par de imágenes estéreo localmente. Las imágenes se guardan sólo cuando se solicitan. + Guardar imagen de la cámara + Reiniciar seguimiento + Úselo si el seguimiento no se recupera en un área bien iluminada. Un reinicio requiere un nuevo origen de seguimiento. + Reiniciar + ¿Reiniciar el seguimiento? + Se perderán las vistas de calibración no guardadas. Mantén las gafas inteligentes quietas y restablece el centro de seguimiento cuando se restablezca el seguimiento. + %1$d / 24 vistas capturadas + Captura en pausa: %1$s + Medida %1$s. Muestre el objetivo de calibración completo en ambas vistas previas y luego quédese quieto. + %1$.1f Hz • antigüedad de la imagen %2$.1f ms • procesamiento %3$.1f ms + Límite de entrada %1$.1f Hz • %2$.0f%% de imágenes de la cámara. El seguimiento de la cabeza continúa con su frecuencia máxima. + %1$d procesado • %2$d descartado • %3$d omitido por límite de entrada + DroidDeck ChArUco 30 mm + DroidDeck - Calibración de Luma Ultra + Imprimir a 100% / Tamaño real. Cada cuadrado: 30 mm (1,181 pulgadas). + Mantenga el objetivo de calibración plano y estacionario; mueve las gafas inteligentes entre capturas. + Verificación de escala: 100 mm (3,937 in) entre marcas + 12 pulgadas (30,48 cm) + 30 cm (11,81 pulgadas) + 20 pulgadas (50,8 cm) + 50 cm (19,69 pulgadas) + Deshabilitado + Esperando seguimiento estable + Desconectado + Los controladores operados con las manos desnudas están apagados + El seguimiento posicional está desactivado o las gafas inteligentes están desconectadas + Se ha solicitado el restablecimiento del centro de seguimiento; mantén las gafas quietas mientras se estabiliza el seguimiento. + Seguimiento perdido: frente a un área bien iluminada con detalles visibles + El origen del seguimiento ha cambiado; pulsa el botón para restablecer el centro de seguimiento y mantén las gafas quietas. + 6DoF activo + Conecte Luma Ultra y habilite el seguimiento posicional. + Calibración verificada para esta conexión. + Calibración verificada y guardada. + Esperando cámaras estéreo + Esperando seguimiento de manos + Mantenga estacionario el objetivo de calibración 5 × 7. Capture más de 24 vistas mientras mueve y gira las gafas inteligentes. + Esperando la siguiente imagen de la cámara. Mantenga quietas las gafas inteligentes. + Comprobación de la siguiente imagen de la cámara. Mantenga visible el objetivo de calibración completo y manténgalo quieto. + Iniciar la calibración primero + No llegó ninguna imagen nueva de la cámara. Verifique la conexión de las gafas inteligentes y las vistas previas de la cámara, luego vuelva a intentarlo. + Reinicio del reloj de la cámara + El sistema de coordenadas de seguimiento ha cambiado. Tus vistas se guardan para su recálculo. Restablece el centro de seguimiento y, a continuación, inicia una nueva configuración para capturar más vistas. + calibración del dispositivo cargada + Calibración de base Luma Ultra cargada + calibración requerida + Toque Iniciar nueva calibración primero. + El restablecimiento del centro de seguimiento está esperando un seguimiento estable. Mantén las gafas quietas un momento. + El seguimiento ha cambiado. Pulsa el botón para restablecer el centro de seguimiento una vez y, a continuación, mantén las gafas quietas antes de capturar. + Captura rechazada: el seguimiento de la cabeza no se sincronizó o cambió durante la captura. Quédate quieto y vuelve a intentarlo. + Calcule la alineación de la cámara antes de verificar la distancia. + el procesamiento de la cámara falló + El seguimiento de la cabeza cambió durante la detección de manos + Esperando la sincronización de la cámara y el cabezal + No se detectaron muñecas. Mantenga las manijas del controlador Joy-Con frente a las gafas inteligentes + No se detectaron manos. Muestre las palmas abiertas frente a las gafas inteligentes. + Muñecas visibles en una sola cámara; mantenga los identificadores de su controlador en la vista compartida + Manos visibles en una sola cámara; mantenga ambas palmas en la vista compartida + Ambas cámaras ven manos, pero la coincidencia izquierda/derecha es ambigua + Se detectaron manos, pero la profundidad estéreo no es consistente + Posición de la muñeca rechazada por controles estéreo o de movimiento + Se detectaron puntos estéreo, pero la geometría de la palma es inconsistente + Calibración completa y verificación de distancia para permitir que las manos + Esperando un seguimiento de cabeza estable; restablece el centro de seguimiento si se solicita. + La observación con cámara es demasiado antigua; esperando un par nuevo + Ajustar %1$.2f px. Mida la distancia seleccionada desde la cámara izquierda hasta el centro del objetivo de calibración y luego valide. + OpenCV no disponible: %1$s + %1$d vistas guardadas restauradas. Calcule la calibración para volver a intentarlo o comience un nuevo conjunto para capturar más. + Capturado %1$d / 24 vistas. Mantenga fijo el objetivo de calibración; Mueva las gafas inteligentes para la siguiente vista. + Captura rechazada: %1$d / 12 esquinas requeridas visibles en ambas cámaras. Muestre más del objetivo de calibración, quédese quieto y vuelva a intentarlo. + La verificación de distancia no pudo finalizar: %1$s. Intentar otra vez. + Detección de manos no disponible: %1$s. Cambie la CPU/GPU o cambie los controladores operados con las manos desnudas para volver a intentarlo. + La detección de manos superó los %1$d ms; observación descartada + %1$d / 2 posiciones de muñeca Joy-Con medidas por estéreo + Palmas seguidas: %1$d / 2; gesto de pinza listo: %2$d; agarre listo: %3$d + Captura de diagnóstico guardada en %1$s + Seguimiento de manos detenido: %1$s + Estéreo %1$d×%2$d; %3$s + El seguimiento de la cabeza y el objetivo de calibración difieren en %1$s (límite de 5 cm/2 pulgadas). Mantenga fijo el objetivo de calibración y espere un seguimiento constante antes de comenzar una nueva serie. Gire e incline suavemente las gafas inteligentes; pausa antes de cada captura. + Capture al menos 24 vistas variadas del objetivo de calibración estacionario. + Gire las gafas inteligentes hacia la izquierda y hacia la derecha, e inclínelas hacia arriba y hacia abajo; el movimiento sin rotación no puede calibrar la alineación de la cámara. + Línea de base de cámara inverosímil + Mueve la cabeza en orientaciones más variadas. + Rotación de cámara a cabezal no válida + La alineación entre la cámara y el cabezal es inconsistente. + La calibración no pudo finalizar. %1$s Tus vistas capturadas se guardan. + El error de reproyección retenida %1$.2f px supera los 2 px. Recalibrar. + %1$d / 24 esquinas de tablero de ajedrez detectadas en ambas cámaras. Mantenga visible el objetivo de calibración completo y manténgalo quieto. Si ya es visible, seleccione 12 pulgadas o 30 cm y mida esa distancia más cercana antes de volver a intentarlo. + El objetivo de calibración es visible, pero su profundidad no se pudo medir de manera confiable. Mantenga las gafas inteligentes quietas y mantenga el objetivo de calibración plano y bien iluminado, luego vuelva a intentarlo. + La ​​medición de la cámara no fue válida. Quédate quieto y vuelve a intentarlo. + Se pasó la verificación de distancia. + Vuelva a verificar la distancia desde la cámara izquierda al centro del objetivo de calibración y luego vuelva a intentarlo. + Las cámaras midieron %1$s; distancia seleccionada %2$s. %3$s + Espere las vistas previas de ambas cámaras antes de comenzar la calibración. + Las vistas guardadas se pueden recalcular. Inicie una nueva calibración para capturar en el sistema de coordenadas de seguimiento actual. + La suma de comprobación del modelo de mano no coincide + OpenCV no se pudo cargar diff --git a/app/src/main/res/values-bg/strings.xml b/app/src/main/res/values-bg/strings.xml index 9f3afeff5b..303feb9f42 100644 --- a/app/src/main/res/values-bg/strings.xml +++ b/app/src/main/res/values-bg/strings.xml @@ -2366,14 +2366,14 @@ Екран Честота на опресняване 3D (един до друг) - Всяко око получава своята половина от картина 3840×1080. Ако картината изчезне, задръжте бутона 2D/3D на очилата. + Превключете смарт очилата на 3D едно до друго. Проследяването на главата се контролира отделно. 3D сигналът не беше потвърден. Опитайте отново, когато 2D картината се върне. Няма картина: очилата са в режим, който този телефон не може да изпрати. Задръжте бутона им 2D/3D или ги изключете и включете отново. Честота на опресняване в 3D 3D за VR игри Превключва на 3D, докато SteamVR работи, и после обратно. - 3D картина - Автоматично: SteamVR запълва изгледа; другите игри висят като екран в 3D и остават плоски в 2D. + Картина + Автоматично показва плоско съдържание и в двете очи и разпознава SteamVR. Изберете „Игра отстрани“ за SBS съдържание. Автоматично Виртуален екран Игра 3D един до друг @@ -2383,20 +2383,20 @@ Тези настройки се прилагат, докато опцията „Играта на очилата“ е включена и играта се показва там. „Автоматично“ запазва тази 2D игра на цял екран. Използвайте виртуален екран, за да настроите ширината, разстоянието и проследяването на главата. Използване на виртуален екран - SteamVR запълва изгледа. Настройте зрителното му поле по-долу; ширината и разстоянието се отнасят само за виртуален екран. + SteamVR запълва изгледа. Регулирайте зрителното си поле във VR; ширината и разстоянието се отнасят само за виртуален екран. Игрите 3D един до друг запълват всяко око. Ширината и разстоянието се отнасят само за виртуален екран. „Автоматично“ държи тази 2D игра неподвижна в изгледа. Изберете „Виртуален екран“ в „Екран“, за да използвате проследяване на главата. Проследяването на главата се отнася за виртуален екран или за работеща игра в SteamVR. - Очила + Устройство Яркост Сила на звука Затъмняване Затъмнява предните стъкла. - Проследяване на главата + Проследяване Проследяване на главата Собствените сензори на очилата завъртат виртуалния екран и SteamVR заедно с главата ви. Центриране на изгледа - Центриране + Центриране на екрана Зрително поле на SteamVR По-ниско приближава SteamVR и запълва очилата; по-високо показва повече около вас. Играете на %1$s @@ -2417,8 +2417,8 @@ Да се премахне ли запазеното калибриране и да се възстановят стойностите по подразбиране за модела? Центрирайте изгледа, след като сложите очилата отново. Нулиране Проследяване на ръцете - Да се проследяват ли ръцете ви с камерата? - Камерата вижда ръцете ви. Когато няма свързан контролер, голите ви ръце стават VR ръцете: съберете палеца и показалеца, за да щракнете, свийте ръка, за да хванете, а за менюто обърнете дланта към себе си и съберете пръсти. С Joy-Con камерата ги поставя там, където са ръцете ви. Изображенията се обработват на това устройство и никога не се запазват или изпращат. + Проследяване на ръце или контролери Joy-Con с камерата на телефона? + Без свързан контролер, камерата на телефона проследява вашите голи ръце във VR: щипнете палеца и показалеца си, за да щракнете, затворете ръката си, за да хванете, и обърнете дланта си към себе си и щипнете, за да отворите менюто. С двойни контролери Joy-Con, камерата проследява позицията им, докато контролерите Joy-Con осигуряват въртене и натискане на бутони. Снимките се обработват на това устройство и никога не се запазват или изпращат. Задна камера Препоръчително. Обикновено по-рязка и по-широкоъгълна. Предна камера @@ -2426,7 +2426,7 @@ Използване на камерата Не сега Проследяване на ръцете с камерата - Когато няма свързан контролер, ръцете ви стават VR ръцете: съберете пръсти, за да щракнете, а за менюто обърнете дланта към себе си и съберете пръсти. С Joy-Con ги поставя там, където ги вижда камерата. Изображенията остават на това устройство. + Използвайте камерата на телефона за жестове с голи ръце или за позициониране на сдвоени контролери Joy-Con във VR. Контролерите Joy-Con осигуряват въртене и натискане на бутони. Поставя на пауза, докато интелигентните очила проследяват ръцете ви или контролерите Joy-Con. Изображенията се обработват само на това устройство. Камера Достъп до камерата Разрешете достъп до камерата, за да започне проследяването на ръцете. @@ -2680,4 +2680,208 @@ %1$s се конвертира за Steam. Не затваряйте DroidDeck. Устройството не може да декодира това видео. Видеото не можа да бъде импортирано + Luma Ultra камери — Експериментално + Проследяване на позицията на Joy-Con + Използвайте камерите на интелигентните очила, за да позиционирате сдвоените си контролери Joy-Con. Въртенето и натискането на бутоните идват от контролерите Joy-Con. Позицията се оценява, когато китките ви са скрити. Заменя контролерите, управлявани с голи ръце, и поставя на пауза проследяването с камерата на телефона. Насочете контролерите Joy-Con напред, когато свързвате или нулирате центъра за проследяване. + Първо активирайте проследяването на позицията. Изисква Joy-Con контролери с възможност за движение на Android 12 или по-нова версия. Изключено по подразбиране. + Интелигентни очила + Настройките за дисплей и проследяване на главата се споделят в менютата, игрите и настолните сесии на DroidDeck. + Свържете интелигентните очила, за да промените настройките им за дисплей и проследяване. Запазените ви настройки се запазват, когато изключите връзката. + VR + Режим на показване + 2D изход + 3D изход + Картина и виртуален екран + Позиция и ниво на пода + Проследяване на ръцете — Експериментално + Състояние на проследяване + 2D резолюция + 3D резолюция + VR резолюция + Автоматично + Същото като 2D / 3D + Изходна резолюция за всяко око. + Активирайте „Игра на смарт очила“, за да изберете оригиналния 30 Hz режим на дисплея. + Виртуален екран с 3DoF + Закрепете плоските игри пред себе си, за да можете да се оглеждате. Активира „Игра на смарт очила“, без да превключвате на 3D. + Ширината и разстоянието актуализират незабавно проследения виртуален екран за менюта, игри и десктоп сесии на DroidDeck. + Позиционното проследяване включва въртене на главата в SteamVR. За проследяване само с въртене, изключете позиционното проследяване. + Контролира движението на главата на виртуалния екран. Позиционното проследяване включва въртене на главата в SteamVR. + Бързи действия + Погледнете къде искате екранът, след което нулирайте центъра за проследяване, за да зададете неговата височина и посока. + Центриране на Joy-Con + Камера на телефона — Експериментално + Проследяване на ръце или контролери Joy-Con + Виртуален екран с 6DoF + Проследяване на позицията — експериментално + Физическо движение във VR и около виртуални екрани. Рестартирането на проследяването отнема малко време. + Текуща височина на очите над пода + Задаване на нивото на пода от текущата височина + Задаване на нивото на пода + Настройка и диагностика на стерео камерата + Проверете калибрирането на камерата и проследяването на ръцете преди игра. + Отваряне на настройката + Контролери, управлявани с голи ръце + Използвайте камерите на интелигентните очила, за да се прицелвате с ръце, щипнете, за да щракнете, и затворете ръката си, за да хванете във VR. Геймпадовете се движат и завъртат. Заменя проследяването на позицията на Joy-Con. Може да забави или да загуби проследяване по време на игри. + Активирайте контролери, управлявани с голи ръце под камерите на Luma Ultra в Проследяване. Първо покажете отворени ръце. + Споделено калибриране на Luma Ultra + Използване на споделената основа Luma Ultra. Калибрирайте собствените си интелигентни очила, за да проверите тяхната точност. + Измереното калибриране е потвърдено + Изисква се валидиране + Контролери, управлявани с голи ръце, стават достъпни след преминаване на проверката на измереното разстояние. + Загуба на проследяване + Огледайте се бавно в добре осветена стая.\nДръжте камерите за проследяване чисти и ги насочвайте към мебели или други видими детайли. + Все още сте заседнали? На вашия телефон: смарт очила → Проследяване → Отворете настройката → Показване на диагностика → Рестартиране на проследяването. + Интелигентните очила са прекъснати + Проверете USB връзката и свържете отново смарт очилата.\nПриемете подканата за USB достъп на телефона си, ако се появи. + След като се свържете, огледайте се бавно в добре осветена стая, за да възстановите проследяването. + Необходимо е повторно центриране + Проследяването се е върнало в нова позиция.\nПогледнете напред, след което докоснете „Нулиране на центъра за проследяване“ на телефона си. + Можете също да намерите „Нулиране на центъра за проследяване“ в „Смарт очила“ → „Проследяване“ → „Отваряне на настройката“. Запазената ви калибрация на камерата се запазва. + Задръжте неподвижно за момент + В процес е нулиране на центъра за проследяване.\nДръжте смарт очилата стабилно, докато проследяването се стабилизира. + Този екран се затваря автоматично, когато проследяването на главата е готово. + Стабилизирано прицелване с ръце + Прицелете се от рамото през дланта. Изключете за въртене, контролирано от китката. + Пространствена настройка + Изчаква се проследяване... + Лява и дясна камери за проследяване + Синхронизация на камерата + Готово + Изчакване камерата и проследяването на главата да се подредят. Поддържайте смарт очилата свързани. + 1. Подгответе мишената за калибриране + Отпечатайте в действителен размер + Всеки квадрат трябва да е с размери 30 mm (1,181 in). Монтирайте листа плоско върху твърда повърхност в добре осветено място. + Отпечатване на калибрационната мишена + 2. Уловете различни изгледи + Дръжте мишената за калибриране неподвижна + Преместете интелигентните очила по-близо, по-далеч и настрани. Завъртете ги наляво/надясно, наклонете ги нагоре/надолу и ги наклонете настрани. Задръжте целта за калибриране в двете камери и правете пауза за кратко преди всяко заснемане. + Стартиране на ново калибриране + Изчакване за синхронизиране на камерата. + Стартирайте ново калибриране за събиране на изгледи. + Поддържайте целта за калибриране видима и в двата прегледа. Уловете най-малко 24 ясни гледки от различни ъгли. + Заснема се... + Заснемане на целевия изглед за калибриране + Изчислете подравняването на камерата + Изчислява се... + Изчисляване на калибриране + 3. Проверете разстоянието + Измерено разстояние + Започнете с 12 инча или 30 см, така че отпечатаните маркери да се откриват по-лесно. Изберете точното измерване, което ще използвате. + Лява камера към центъра на целта за калибриране + Проверка на разстоянието... + Проверка на разстоянието + Диагностика + Показване на диагностика + Инструменти за възстановяване на времето и проследяването на камерата. + Време на камерата + Входящи данни от проследяване на ръце + Изчакване на времето на камерата. + Изображения от камера + GPU разпознаване на ръце + По подразбиране се използва CPU. GPU е експериментален и може да предизвика рестартиране на SteamVR. Изборът се нулира при рестартиране на проследяването. + Леко откриване на модели на ръце + Използвайте Lite детектор за длан и Lite ключови точки на ръцете. Проверете точността на прицелване, прищипване и хващане. Нулира се при рестартиране на проследяването. + Автоматична входна честота за проследяване на ръцете + Коригиране на входа към скоростта на обработка. Нулира се при рестартиране на проследяването. + Ограничаване на входната честота за проследяване на ръцете + Използвайте половината изображения от камерата. Изключете, за да сравните максималната честота. Нулира се при рестартиране на проследяването. + Диагностично улавяне + Запазете една двойка стерео изображения локално. Изображенията се запазват само при поискване. + Запазване на изображението от камерата + Рестартиране на проследяването + Използвайте, ако проследяването не се възстанови в добре осветена зона. Рестартирането изисква нов произход за проследяване. + Рестартиране + Рестартиране на проследяването? + Незапазените изгледи за калибриране ще бъдат загубени. Дръжте смарт очилата неподвижно след това и нулирайте центъра за проследяване, когато проследяването се възстанови. + %1$d / 24 заснети изгледа + Заснемането е на пауза: %1$s + Мярка %1$s. Покажете пълната цел за калибриране и в двете визуализации, след което задръжте неподвижно. + %1$.1f Hz • възраст на изображението %2$.1f ms • обработка %3$.1f ms + Входящо ограничение %1$.1f Hz • %2$.0f%% на изображения от камерата. Проследяването на главата продължава на максималната си честота. + %1$d обработено • %2$d изпуснато • %3$d пропуснато от въведено ограничение + DroidDeck ChArUco 30 mm + DroidDeck – калибриране на Luma Ultra + Печат при 100%/действителен размер. Всеки квадрат: 30 мм (1,181 инча). + Дръжте мишената за калибриране плоска и неподвижна; преместете интелигентните очила между заснеманията. + Проверка на мащаба: 100 mm (3,937 инча) между отметките + 12 инча (30,48 см) + 30 см (11,81 инча) + 20 инча (50,8 см) + 50 см (19,69 инча) + Дезактивирано + Изчакване на стабилно проследяване + Прекъсната връзка + Контролерите, работещи с голи ръце, са изключени + Позиционното проследяване е изключено или смарт очилата са изключени + Заявено е нулиране на центъра за проследяване — задръжте неподвижно, докато проследяването се стабилизира. + Проследяването е загубено — лице в добре осветена зона с видими детайли + Произходът на проследяване е променен — докоснете „Нулиране на центъра за проследяване“, след което задръжте неподвижно. + 6DoF активен + Свържете Luma Ultra и активирайте позиционното проследяване. + Калибрирането е потвърдено за тази връзка. + Калибрирането е потвърдено и запазено. + Изчакване на стерео камери + Изчакване за проследяване на ръцете + Дръжте мишената за калибриране 5 × 7 неподвижна. Уловете 24+ изгледа, докато местите и въртите смарт очилата. + Изчакване на следващото изображение от камерата. Дръжте умните очила неподвижно. + Проверка на следващото изображение от камерата. Дръжте целта за пълно калибриране видима и задръжте неподвижно. + Първо започнете калибриране + Не е пристигнало ново изображение от камерата. Проверете връзката на интелигентните очила и прегледите на камерата, след което опитайте отново. + Нулиране на часовника на фотоапарата + Координатната система за проследяване е променена. Вашите изгледи са запазени за преизчисляване. Нулирайте центъра за проследяване, след което започнете нов набор, за да заснемете още изгледи. + калибрирането на устройството е заредено + Заредено е базовото калибриране на Luma Ultra + изисква се калибриране + Докоснете Първо стартиране на ново калибриране. + „Нулиране на центъра за проследяване“ чака стабилно проследяване. Задръжте неподвижно за момент. + Проследяването е променено. Докоснете „Нулиране на центъра за проследяване“ веднъж, след което задръжте неподвижно, преди да заснемете. + Заснемането е отхвърлено: проследяването на главата не беше синхронизирано или се промени по време на заснемането. Стойте неподвижно и опитайте отново. + Изчислете подравняването на камерата, преди да проверите разстоянието. + обработката на камерата е неуспешна + Проследяването на главата е променено по време на откриване на ръце + Изчакване за синхронизиране на камерата и главата + Не са открити китки. Дръжте дръжките на вашия контролер Joy-Con пред смарт очилата + Няма открити ръце. Покажете разтворени длани пред умните очила + Китките се виждат само в една камера; дръжте дръжките на контролера си в споделения изглед + Ръцете се виждат само в една камера; дръжте двете длани в споделения изглед + И двете камери виждат ръце, но съвпадението ляво/дясно е двусмислено + Ръцете са открити, но стерео дълбочината е непостоянна + Позиция на китката, отхвърлена от проверки за стерео или движение + Открити са стерео точки, но геометрията на дланта е несъвместима + Завършете калибрирането и проверката на разстоянието, за да активирате ръцете + Изчакване на стабилно проследяване на главата; нулиране на центъра за проследяване, ако е поискано. + Наблюдението на камерата е твърде старо; в очакване на нов чифт + Побиране на %1$.2f пиксела. Измерете избраното разстояние от лявата камера до центъра на целта за калибриране, след което потвърдете. + OpenCV не е наличен: %1$s + %1$d запазените изгледи са възстановени. Изчислете калибрирането, за да опитате отново, или започнете нов набор, за да заснемете повече. + Заснето %1$d / 24 прегледа. Дръжте целта за калибриране фиксирана; преместете смарт очилата за следващия изглед. + Заснемането е отхвърлено: %1$d / 12 задължителни ъгъла, видими и в двете камери. Покажете още от целта за калибриране, задръжте неподвижно и опитайте отново. + Проверката на разстоянието не можа да завърши: %1$s. Опитайте отново. + Откриване на недостъпни ръце: %1$s. Променете CPU/GPU или превключете контролерите, управлявани с голи ръце, за да опитате отново. + Откриването на ръце е превишено %1$d ms; наблюдението е отхвърлено + %1$d / 2 позиции на китката на Joy-Con, измерени чрез стерео + Проследени длани: %1$d / 2; готовност за щипване: %2$d; готовност за хващане: %3$d + Записан диагностичен запис в %1$s + Проследяването на ръцете е спряно: %1$s + Стерео %1$d×%2$d; %3$s + Проследяването на главата и целта за калибриране не съвпадат с %1$s (ограничение 5 см / 2 инча). Дръжте целта за калибриране фиксирана и изчакайте стабилно проследяване, преди да започнете нов набор. Внимателно завъртете и наклонете умните очила; пауза преди всяко заснемане. + Заснемане на най-малко 24 разнообразни изгледа на неподвижната цел за калибриране. + Завъртете умните очила наляво и надясно и ги наклонете нагоре и надолу; движение без завъртане не може да калибрира подравняването на камерата. + Неправдоподобна базова линия на камерата + Преместете главата си в по-разнообразни ориентации. + Невалидно завъртане на камерата към главата + Подравняването на камерата към главата е непоследователно. + Калибрирането не можа да завърши. %1$s Вашите заснети изгледи се запазват. + Грешка при повторна проекция на задържане %1$.2f px надвишава 2 px. Калибрирайте отново. + %1$d / 24 ъгъла на шахматна дъска, открити и в двете камери. Дръжте целта за пълно калибриране видима и задръжте неподвижно. Ако вече се вижда, изберете 12 инча или 30 см и измерете това по-близко разстояние, преди да опитате отново. + Целта за калибриране се вижда, но дълбочината й не може да бъде надеждно измерена. Дръжте умните очила неподвижно и дръжте мишената за калибриране плоска и добре осветена, след което опитайте отново. + Измерването на камерата е невалидно. Задръжте неподвижно и опитайте отново. + Проверката на разстоянието е премината. + Проверете отново разстоянието от лявата камера до центъра на целта за калибриране, след което опитайте отново. + Измерени камери %1$s; избраното разстояние %2$s. %3$s + Изчакайте визуализациите на двете камери, преди да започнете калибрирането. + Запазените изгледи могат да бъдат преизчислени. Започнете ново калибриране за заснемане в текущата координатна система за проследяване. + Несъответствие на контролната сума на модела на ръката + OpenCV не можа да се зареди diff --git a/app/src/main/res/values-cs/strings.xml b/app/src/main/res/values-cs/strings.xml index 67fa3ad179..feb7fdf84a 100644 --- a/app/src/main/res/values-cs/strings.xml +++ b/app/src/main/res/values-cs/strings.xml @@ -2416,14 +2416,14 @@ Displej Obnovovací frekvence 3D (vedle sebe) - Každé oko dostane vlastní polovinu obrazu 3840×1080. Pokud obraz vypadne, podržte na brýlích tlačítko 2D/3D. + Přepněte chytré brýle do 3D zobrazení vedle sebe. Sledování hlavy se ovládá samostatně. Signál 3D se nepodařilo potvrdit. Zkuste to znovu, až se vrátí obraz 2D. Žádný obraz: brýle jsou v režimu, který tento telefon neumí vyslat. Podržte jejich tlačítko 2D/3D, nebo je odpojte a znovu připojte. Obnovovací frekvence ve 3D 3D pro hry VR Při běhu SteamVR přepne na 3D a potom zpět. - Obraz 3D - Automaticky: SteamVR vyplní zorné pole; ostatní hry visí ve 3D jako obrazovka a ve 2D zůstanou ploché. + Obrázek + Automaticky zobrazuje plochý obsah v obou očích a detekuje SteamVR. Pro obsah SBS vyberte možnost Hra vedle sebe. Automaticky Virtuální obrazovka Hra 3D vedle sebe @@ -2433,20 +2433,20 @@ Tato nastavení platí, když je zapnutá možnost „Hra v brýlích“ a hra se v nich zobrazuje. Režim Automaticky drží tuto 2D hru na celou obrazovku. Chcete-li upravit její šířku, vzdálenost a sledování hlavy, použijte virtuální obrazovku. Použít virtuální obrazovku - SteamVR vyplní celý pohled. Jeho zorné pole upravte níže; šířka a vzdálenost platí jen pro virtuální obrazovku. + SteamVR vyplní zobrazení. Upravte zorné pole ve VR; šířka a vzdálenost platí pouze pro virtuální obrazovku. Hry 3D vedle sebe vyplní zorné pole každého oka. Šířka a vzdálenost platí jen pro virtuální obrazovku. Režim Automaticky drží tuto 2D hru pevně v zorném poli. Chcete-li použít sledování hlavy, zvolte v části Displej možnost „Virtuální obrazovka“. Sledování hlavy platí pro virtuální obrazovku nebo spuštěnou hru SteamVR. - Brýle + Zařízení Jas Hlasitost Zatmavení Ztmaví přední skla. - Sledování hlavy + Sledování Sledování hlavy Vlastní senzory brýlí otáčejí virtuální obrazovkou a SteamVR podle pohybu hlavy. Vycentrovat pohled - Vycentrovat + Vycentrovat obrazovku Zorné pole SteamVR Nižší hodnota přiblíží SteamVR a vyplní brýle; vyšší ukáže víc z okolí. Hraje se na %1$s @@ -2467,8 +2467,8 @@ Odebrat uloženou kalibraci a obnovit výchozí hodnoty modelu? Po opětovném nasazení brýlí pohled vycentrujte. Resetovat Sledování rukou - Sledovat ruce pomocí kamery? - Kamera vidí vaše ruce. Když není připojen žádný ovladač, stanou se vaše holé ruce rukama ve VR: spojením palce a ukazováčku kliknete, sevřením ruky uchopíte a menu otevřete, když dlaň otočíte k sobě a spojíte prsty. S Joy-Cony je umístí tam, kde vaše ruce skutečně jsou. Obrázky se zpracovávají na tomto zařízení a nikdy se neukládají ani neodesílají. + Sledování rukou nebo ovladačů Joy-Con pomocí fotoaparátu telefonu? + Bez připojeného ovladače sleduje fotoaparát telefonu ve VR vaše holé ruce: sevřením palce a ukazováčku kliknete, sevřením ruky uchopíte a otočením dlaně k sobě a sevřením otevřete nabídku. U spárovaných ovladačů Joy-Con fotoaparát sleduje jejich polohu, zatímco ovladače Joy-Con zajišťují otáčení a ovládání tlačítky. Snímky se zpracovávají na tomto zařízení a nikdy se neukládají ani neodesílají. Zadní kamera Doporučeno. Obvykle ostřejší a širší. Přední kamera @@ -2476,7 +2476,7 @@ Použít kameru Teď ne Sledování rukou kamerou - Když není připojen žádný ovladač, stanou se vaše ruce rukama ve VR: spojením prstů kliknete, dlaní k sobě a spojením prstů otevřete menu. S Joy-Cony je umístí tam, kde je vidí kamera. Obrázky zůstávají na tomto zařízení. + Použijte kameru telefonu pro gesta holou rukou nebo k umístění spárovaných ovladačů Joy-Con ve VR. Ovladače Joy-Con poskytují otáčení a vstupy tlačítek. Pozastaví, zatímco chytré brýle sledují vaše ruce nebo ovladače Joy-Con. Snímky se zpracovávají pouze na tomto zařízení. Kamera Přístup ke kameře Povolte přístup ke kameře, aby mohlo začít sledování rukou. @@ -2748,4 +2748,208 @@ Převádí se %1$s pro Steam. Nechte DroidDeck otevřený. Toto zařízení video nedokáže dekódovat. Video se nepodařilo importovat + Kamery Luma Ultra — Experimentální + Sledování polohy Joy-Conů + Použijte kamery chytrých brýlí k umístění spárovaných ovladačů Joy-Con. Otáčení a vstupy tlačítek pocházejí z ovladačů Joy-Con. Poloha se odhaduje, když máte skrytá zápěstí. Nahrazuje ovladače ovládané holýma rukama a pozastavuje sledování fotoaparátem telefonu. Při připojování nebo resetování centra sledování namiřte ovladače Joy-Con dopředu. + Nejprve povolte sledování polohy. Vyžaduje ovladače Joy-Con s funkcí detekce pohybu v systému Android 12 nebo novějším. Ve výchozím nastavení vypnuto. + Chytré brýle + Nastavení zobrazení a sledování hlavy jsou sdílena mezi nabídkami, hrami a relacemi na počítači DroidDeck. + Připojte chytré brýle a změňte jejich nastavení zobrazení a sledování. Uložená nastavení zůstanou zachována i po odpojení. + VR + Režim zobrazení + 2D výstup + 3D výstup + Obraz a virtuální obrazovka + Poloha a úroveň podlahy + Sledování rukou — Experimentální + Stav sledování + 2D rozlišení + 3D rozlišení + VR rozlišení + Automatické + Stejné jako 2D / 3D + Výstupní rozlišení pro každé oko. + Povolte Hra na chytrých brýlích pro výběr nativního 30Hz režimu displeje. + Virtuální obrazovka 3DoF + Ukotvěte ploché hry před sebe, abyste se mohli rozhlédnout. Povolí Hra na chytrých brýlích bez přepínání do 3D. + Šířka a vzdálenost okamžitě aktualizují sledovanou virtuální obrazovku pro nabídky DroidDeck, hry a relace plochy. + Sledování polohy zahrnuje rotaci hlavy ve SteamVR. Pro sledování pouze rotace vypněte sledování polohy. + Řídí pohyb hlavy na virtuální obrazovce. Sledování polohy zahrnuje rotaci hlavy ve SteamVR. + Rychlé akce + Podívejte se, kam chcete umístit obrazovku, a poté resetujte centrum sledování, abyste nastavili její výšku a směr. + Vycentrovat Joy-Con + Fotoaparát telefonu – Experimentální + Sledování rukou nebo ovladačů Joy-Con + Virtuální obrazovka s 6DoF + Sledování polohy – experimentální + Fyzický pohyb ve VR a kolem virtuálních obrazovek. Restartování sledování chvíli trvá. + Aktuální výška očí nad podlahou + Nastavit úroveň podlahy z aktuální výšky + Nastavit úroveň podlahy + Nastavení a diagnostika stereo kamery + Před hraním zkontrolujte kalibraci kamery a sledování rukou. + Otevřít nastavení + Ovladače ovládané holýma rukama + Použijte kamery chytrých brýlí k míření rukama, sevřením prstů pro kliknutí a sevřením ruky pro uchopení ve VR. Gamepady se pohybují a otáčejí. Nahrazuje sledování polohy Joy-Con. Během her může docházet ke zpoždění nebo ztrátě sledování. + Povolte ovladače ovládané holýma rukama pod kamerami Luma Ultra v režimu Sledování. Nejprve zobrazte otevřené ruce. + Sdílená kalibrace Luma Ultra + Používání sdílené základny Luma Ultra. Kalibrace vlastních chytrých brýlí pro ověření jejich přesnosti. + Naměřená kalibrace ověřena + Vyžadováno ověření + Ovladače ovládané holýma rukama budou k dispozici po úspěšném provedení kontroly naměřené vzdálenosti. + Sledování ztraceno + Pomalu se rozhlédněte v dobře osvětlené místnosti.\nUdržujte sledovací kamery v dostatečné vzdálenosti a natočte je k nábytku nebo jiným viditelným detailům. + Stále se zasekl? Na telefonu: chytré brýle → Sledování → Otevřít nastavení → Zobrazit diagnostiku → Restartovat sledování. + Chytré brýle odpojeny + Zkontrolujte připojení USB a znovu připojte chytré brýle.\nPokud se zobrazí výzva k přístupu přes USB na telefonu, přijměte ji. + Po připojení se pomalu rozhlédněte v dobře osvětlené místnosti a obnovte sledování. + Je nutné znovu vycentrovat sledování + Sledování se vrátilo do nové polohy.\nPodívejte se dopředu a poté klepněte na resetovat centrum sledování na telefonu. + Obnovení centra sledování najdete také v chytrých brýlích → Sledování → Otevřít nastavení. Vaše uložená kalibrace fotoaparátu se zachová. + Chvíli vydržte + Probíhá resetování centra sledování.\nDržte chytré brýle stabilně, dokud se sledování neustálí. + Tato obrazovka se automaticky zavře, když je připraveno sledování hlavy. + Stabilizované míření rukama + Zamiřte z ramene přes dlaň. Vypněte pro otáčení ovládané zápěstím. + Prostorové nastavení + Čekání na sledování… + Levé a pravé sledovací kamery + Synchronizace kamery + Připraveno + Čekání na seřazení kamery a sledování hlavy. Udržujte chytré brýle připojené. + 1. Připravte kalibrační cíl + Tisk ve skutečné velikosti + Každý čtverec musí měřit 30 mm (1,181 palce). Připevněte list naplocho na pevný povrch na dobře osvětlené místo. + Vytisknout kalibrační terč + 2. Zachyťte různé pohledy + Udržujte kalibrační cíl nehybný + Posuňte chytré brýle blíže, dále a do stran. Otočte je doleva/doprava, nakloňte je nahoru/dolů a nakloňte je do stran. Ponechejte kalibrační cíl v obou kamerách a před každým zachycením se na chvíli zastavte. + Spusťte novou kalibraci + Čekání na synchronizaci kamery. + Spusťte novou kalibraci pro sběr pohledů. + Ponechat cíl kalibrace viditelný v obou náhledech. Zachyťte alespoň 24 ostrých pohledů z různých úhlů. + Zachycuji… + Zachycení pohledu na cíl kalibrace + Vypočítat zarovnání kamery + Počítám… + Vypočítat kalibraci + 3. Zkontrolujte vzdálenost + Změřená vzdálenost + Začněte na 12 palcích nebo 30 cm, aby byly vytištěné značky snadněji rozpoznatelné. Vyberte si přesné měření, které budete používat. + Levá kamera do středu kalibračního cíle + Kontrola vzdálenosti… + Ověřte vzdálenost + Diagnostika + Zobrazit diagnostiku + Nástroje pro obnovu časování a sledování kamery. + Časování kamery + Vstup ze sledování rukou + Čekání na časování kamery. + Snímky z fotoaparátu + GPU detekce rukou + CPU je výchozí. GPU je experimentální a může způsobit restartování SteamVR. Tato volba se resetuje při restartu sledování. + Lite detekce modelů rukou + Použijte detektor dlaní Lite a klíčové body Lite na rukou. Zkontrolujte přesnost míření, štípnutí a uchopení. Resetuje se při restartu sledování. + Automatická vstupní frekvence pro sledování rukou + Upravte vstup podle rychlosti zpracování. Resetuje se při restartu sledování. + Limitní vstupní frekvence pro sledování rukou + Použijte polovinu snímků z fotoaparátu. Vypněte pro porovnání maximální frekvence. Resetuje se při restartu sledování. + Diagnostické zachycení + Lokálně uložte jeden pár stereo obrázků. Obrázky se ukládají pouze na vyžádání. + Uložte snímek z fotoaparátu + Restartujte sledování + Použijte, pokud se sledování neobnoví v dobře osvětlené oblasti. Restart vyžaduje nový zdroj sledování. + Restartujte + Restartovat sledování? + Neuložené kalibrační pohledy budou ztraceny. Poté držte chytré brýle v klidu a resetujte centrum sledování, jakmile se sledování obnoví. + Zachyceno %1$d / 24 zobrazení + Záznam pozastaven: %1$s + Míra %1$s. Ukažte kompletní kalibrační cíl v obou náhledech a poté nehybně podržte. + %1$.1f Hz • stáří snímku %2$.1f ms • zpracování %3$.1f ms + Limit vstupu %1$.1f Hz • %2$.0f%% snímků z kamery. Sledování hlavy pokračuje na maximální frekvenci. + %1$d zpracováno • %2$d zrušeno • %3$d přeskočeno limitem vstupu + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra kalibrace + Tisk při 100% / Skutečná velikost. Každý čtverec: 30 mm (1,181 palce). + Udržujte kalibrační cíl plochý a nehybný; přesouvejte chytré brýle mezi snímky. + Kontrola měřítka: 100 mm (3,937 palce) mezi dílky + 12 palců (30,48 cm) + 30 cm (11,81 palce) + 20 palců (50,8 cm) + 50 cm (19,69 palce) + Zakázáno + Čekání na stabilní sledování + Odpojeno + Ovladače ovládané holýma rukama jsou vypnuté + Sledování polohy je vypnuto nebo jsou odpojeny chytré brýle + Požadováno resetování centra sledování – držte se v klidu, dokud se sledování nestabilizuje. + Sledování ztraceno – čelte dobře osvětlené oblasti s viditelnými detaily + Změněn počátek sledování – klepněte na resetování centra sledování a poté držte v klidu. + 6DoF aktivní + Připojte Luma Ultra a povolte sledování polohy. + Kalibrace ověřena pro toto připojení. + Kalibrace ověřena a uložena. + Čekání na stereo kamery + Čekání na sledování rukou + Udržujte kalibrační terč 5 × 7 nehybný. Zachyťte více než 24 pohledů při pohybu a otáčení chytrými brýlemi. + Čekání na další snímek z kamery. Držte chytré brýle v klidu. + Kontrola dalšího snímku z kamery. Udržujte celý kalibrační cíl viditelný a držte jej v klidu. + Nejprve spusťte kalibraci + Nedorazil žádný nový snímek z kamery. Zkontrolujte připojení chytrých brýlí a náhledy fotoaparátu a zkuste to znovu. + Hodiny fotoaparátu byly resetovány + Souřadnicový systém sledování se změnil. Vaše pohledy jsou uloženy pro přepočet. Obnovte centrum sledování a poté spusťte novou sadu pro zachycení dalších pohledů. + načtena kalibrace zařízení + Načtena základní kalibrace Luma Ultra + nutná kalibrace + Nejprve klepněte na Spustit novou kalibraci. + Obnovení centra sledování čeká na stabilní sledování. Chvíli držte v klidu. + Sledování se změnilo. Klepněte jednou na resetování centra sledování a poté držte v klidu před zachycením. + Snímek odmítnut: sledování hlavy nebylo synchronizované nebo se během snímání změnilo. Nehýbejte se a zkuste to znovu. + Před kontrolou vzdálenosti vypočítejte vyrovnání kamery. + zpracování fotoaparátu se nezdařilo + Sledování hlavy se změnilo během detekce rukou + Čekání na synchronizaci kamery a hlavy + Nebyla zjištěna žádná zápěstí. Držte rukojeti ovladače Joy-Con před chytrými brýlemi + Nebyly zjištěny žádné ruce. Ukažte před chytrými brýlemi otevřené dlaně + Zápěstí viditelná pouze v jedné kameře; ponechte úchyty ovladače ve sdíleném zobrazení + Ruce viditelné pouze v jedné kameře; mějte obě dlaně ve sdíleném pohledu + Obě kamery vidí ruce, ale shoda vlevo/vpravo je nejednoznačná + Ruce byly detekovány, ale stereo hloubka je nekonzistentní + Poloha zápěstí zamítnuta stereo nebo kontrolou pohybu + Byly zjištěny stereo body, ale geometrie dlaně je nekonzistentní + Dokončete kalibraci a kontrolu vzdálenosti pro aktivaci rukou + Čekání na stabilní sledování hlavy; resetování centra sledování je možné, pokud je požadováno. + Pozorování kamerou je příliš staré; čekání na nový pár + Přizpůsobit %1$.2f pixelům. Změřte vybranou vzdálenost od levé kamery ke středu kalibračního cíle a poté potvrďte. + OpenCV není k dispozici: %1$s + Bylo obnoveno %1$d uložených zobrazení. Vypočítejte kalibraci a zkuste to znovu, nebo spusťte novou sadu a zachyťte více. + Pořízeno %1$d / 24 zobrazení. Udržujte kalibrační cíl pevný; posuňte chytré brýle pro další pohled. + Snímek zamítnut: %1$d / 12 požadovaných rohů viditelných v obou kamerách. Ukažte více z kalibračního cíle, nehýbejte se a zkuste to znovu. + Kontrola vzdálenosti nemohla být dokončena: %1$s. Zkuste to znovu. + Detekce rukou není k dispozici: %1$s. Změňte CPU/GPU nebo přepněte řadiče ovládané holýma rukama a zkuste to znovu. + Detekce rukou přesáhla %1$d ms; pozorování vyřazeno + %1$d / 2 polohy zápěstí Joy-Con měřené stereo + Sledované dlaně: %1$d / 2; připraveno sevření prstů: %2$d; připraveno uchopení: %3$d + Diagnostický záznam byl uložen do %1$s + Sledování rukou zastaveno: %1$s + Stereo %1$d×%2$d; %3$s + Sledování hlavy a kalibrační cíl nesouhlasí podle %1$s (limit 5 cm / 2 palce). Před spuštěním nové sady ponechte kalibrační cíl pevný a počkejte na stabilní sledování. Chytré brýle jemně otáčejte a naklánějte; pauza před každým zachycením. + Zachyťte alespoň 24 různých pohledů na stacionární kalibrační cíl. + Otočte chytré brýle doleva a doprava a naklánějte je nahoru a dolů; pohyb bez rotace nemůže kalibrovat zarovnání kamery. + Nepravděpodobná základní linie fotoaparátu + Pohybujte hlavou různými směry. + Neplatné otáčení kamery proti hlavě + Zarovnání mezi kamerou a hlavou je nekonzistentní. + Kalibraci nelze dokončit. %1$s Vaše zachycená zobrazení jsou uložena. + Zpožděná chyba reprojekce %1$.2f px přesahuje 2 px. Překalibrovat. + %1$d / 24 šachovnicových rohů zjištěno v obou kamerách. Udržujte celý kalibrační cíl viditelný a držte jej v klidu. Pokud je již viditelná, vyberte 12 palců nebo 30 cm a před dalším pokusem změřte tuto bližší vzdálenost. + Kalibrační terč je viditelný, ale jeho hloubku nebylo možné spolehlivě změřit. Držte chytré brýle v klidu a udržujte kalibrační terč plochý a dobře osvětlený, pak to zkuste znovu. + Měření kamery bylo neplatné. Nehýbejte se a zkuste to znovu. + Kontrola vzdálenosti prošla. + Znovu zkontrolujte vzdálenost od levé kamery ke středu kalibračního cíle a zkuste to znovu. + Fotoaparáty naměřeny %1$s; vybraná vzdálenost %2$s. %3$s + Před zahájením kalibrace počkejte na náhledy obou kamer. + Uložená zobrazení lze přepočítat. Spusťte novou kalibraci pro zachycení v aktuálním sledovacím souřadnicovém systému. + Neshoda kontrolního součtu modelu ruky + OpenCV se nepodařilo načíst diff --git a/app/src/main/res/values-da/strings.xml b/app/src/main/res/values-da/strings.xml index 91503e0ee4..6186aa6a64 100644 --- a/app/src/main/res/values-da/strings.xml +++ b/app/src/main/res/values-da/strings.xml @@ -2366,14 +2366,14 @@ Skærm Opdateringshastighed 3D (side-by-side) - Hvert øje får sin egen halvdel af et billede på 3840×1080. Forsvinder billedet, så hold brillens 2D/3D-knap inde. + Skift smartbrillerne til side-om-side 3D. Hovedsporing styres separat. 3D-signalet blev ikke bekræftet. Prøv igen, når 2D-billedet er tilbage. Intet billede: brillen er i en tilstand, som telefonen ikke kan sende. Hold dens 2D/3D-knap inde, eller tag stikket ud og sæt det i igen. 3D-opdateringshastighed 3D til VR-spil Skifter til 3D, mens SteamVR kører, og tilbage bagefter. - 3D-billede - Automatisk: SteamVR fylder synsfeltet; andre spil svæver som en skærm i 3D og forbliver flade i 2D. + Billede + Automatisk viser fladt indhold i begge øjne og registrerer SteamVR. Vælg Side-om-side-spil for SBS-indhold. Automatisk Virtuel skærm Side-by-side-spil @@ -2383,20 +2383,20 @@ Disse indstillinger gælder, mens Spil på brillen er slået til, og spillet vises der. Automatisk holder dette 2D-spil i fuld skærm. Brug en virtuel skærm for at justere bredde, afstand og hovedsporing. Brug virtuel skærm - SteamVR fylder hele billedet. Juster synsfeltet nedenfor; bredde og afstand gælder kun for en virtuel skærm. + SteamVR udfylder visningen. Juster dens synsfelt i VR; bredde og afstand gælder kun for en virtuel skærm. Side-by-side-spil fylder hvert øje. Bredde og afstand gælder kun for en virtuel skærm. Automatisk holder dette 2D-spil fast i synsfeltet. Vælg Virtuel skærm under Skærm for at bruge hovedsporing. Hovedsporing gælder for en virtuel skærm eller et kørende SteamVR-spil. - Brille + Enhed Lysstyrke Lydstyrke Solafskærmning Gør de forreste glas mørkere. - Hovedsporing + Sporing Hovedsporing Brillens egne sensorer drejer den virtuelle skærm og SteamVR med dit hoved. Centrer visning - Centrer + Centrer skærmen igen SteamVR-synsfelt Lavere bringer SteamVR tættere på og fylder brillen; højere viser mere omkring dig. Spiller på %1$s @@ -2417,8 +2417,8 @@ Vil du fjerne den gemte kalibrering og gendanne modellens standardværdier? Centrer, når du har taget brillen på igen. Nulstil Håndsporing - Spor dine hænder med kameraet? - Kameraet kan se dine hænder. Uden tilsluttet controller bliver dine bare hænder til VR-hænderne: knib tommel- og pegefinger sammen for at klikke, luk hånden for at gribe, og vend håndfladen mod dig og knib for at åbne menuen. Med Joy-Cons placerer det dem, hvor dine hænder virkelig er. Billeder behandles på denne enhed og gemmes eller sendes aldrig. + Spor hænder eller Joy-Con-controllere med telefonkameraet? + Uden en controller tilsluttet, sporer telefonkameraet dine bare hænder i VR: knib din tommelfinger og pegefinger for at klikke, luk din hånd for at gribe, og drej din håndflade mod dig og knib for at åbne menuen. Med parrede Joy-Con-controllere sporer kameraet deres position, mens Joy-Con-controllerne giver rotation og knapinput. Billeder behandles på denne enhed og gemmes eller sendes aldrig. Bagkamera Anbefales. Som regel skarpere og bredere. Frontkamera @@ -2426,7 +2426,7 @@ Brug kamera Ikke nu Håndsporing med kamera - Uden tilsluttet controller bliver dine hænder til VR-hænderne: knib for at klikke, vend håndfladen mod dig og knib for menuen. Med Joy-Cons placeres de, hvor kameraet ser dem. Billeder bliver på denne enhed. + Brug telefonkameraet til bevægelser med bare hænder eller til at placere parrede Joy-Con-controllere i VR. Joy-Con-controllere giver rotation og knapinput. Pauserer, mens smartglassene sporer dine hænder eller Joy-Con-controllere. Billeder behandles kun på denne enhed. Kamera Kameraadgang Tillad kameraadgang, så håndsporing kan starte. @@ -2680,4 +2680,208 @@ Konverterer %1$s til Steam. Hold DroidDeck åben. Enheden kan ikke afkode videoen. Kunne ikke importere videoen + Luma Ultra-kameraer — Eksperimentel + Joy-Con-positionssporing + Brug smartglass-kameraerne til at placere dine parrede Joy-Con-controllere. Rotation og knapinput kommer fra Joy-Con-controllerne. Positionen estimeres, når dine håndled er skjulte. Erstatter controllere, der betjenes med bare hænder, og sætter telefonkameraets sporing på pause. Ret Joy-Con-controllerne fremad, når du tilslutter eller nulstiller sporingscentret. + Aktiver positionssporing først. Kræver bevægelseskompatible Joy-Con-controllere på Android 12 eller nyere. Fra som standard. + Smartglass + Indstillinger for skærm- og hovedsporing deles på tværs af DroidDeck-menuer, spil og desktopsessioner. + Tilslut smartglass for at ændre deres skærm- og sporingsindstillinger. Dine gemte indstillinger gemmes, når du afbryder forbindelsen. + VR + Visningstilstand + 2D-output + 3D-output + Billede og virtuel skærm + Position og gulvniveau + Sporing af hænder — Eksperimentel + Sporingsstatus + 2D-opløsning + 3D-opløsning + VR-opløsning + Automatisk + Samme som 2D / 3D + Outputopløsning pr. øje. + Aktiver Spil på smartbriller for at vælge skærmens native 30 Hz-tilstand. + 3DoF virtuel skærm + Forankre flade spil foran dig, så du kan se dig omkring. Aktiverer Spil på smartbriller uden at skifte til 3D. + Bredde og afstand opdaterer den sporede virtuelle skærm til DroidDeck-menuer, spil og desktopsessioner med det samme. + Positionssporing inkluderer hovedrotation i SteamVR. For sporing kun med rotation skal du slå positionssporing fra. + Styrer hovedbevægelse på den virtuelle skærm. Positionssporing inkluderer hovedrotation i SteamVR. + Hurtige handlinger + Se, hvor du vil have skærmen, og nulstil derefter sporingscentret for at indstille dens højde og retning. + Centrer Joy-Con igen + Telefonkamera — Eksperimentel + Spor hænder eller Joy-Con-controllere + 6DoF virtuel skærm + Positionssporing — eksperimentel + Fysisk bevægelse i VR og omkring virtuelle skærme. Genstart af sporing tager et øjeblik. + Aktuel øjenhøjde over gulv + Indstil gulvniveau fra aktuel højde + Indstil gulvniveau + Opsætning og diagnosticering af stereokamera + Kontroller kamerakalibrering og sporing af hænder før du spiller. + Åbn opsætning + Controllere, der betjenes med bare hænder + Brug smartbrillernes kameraer til at sigte med dine hænder, knib for at klikke og luk din hånd for at gribe i VR. Gamepad-pinde bevæger sig og drejer. Erstatter Joy-Con-positionssporing. Kan forsinke eller miste sporing under spil. + Aktiver controllere, der betjenes med bare hænder under Luma Ultra-kameraer i Sporing. Vis åbne hænder først. + Delt Luma Ultra-kalibrering + Brug af den delte Luma Ultra-base. Kalibrer dine egne smartbriller for at bekræfte deres nøjagtighed. + Målt kalibrering verificeret + Validering påkrævet + Controllere, der betjenes med bare hænder, bliver tilgængelige, når den målte afstandskontrol er bestået. + Sporing mistet + Se dig langsomt omkring i et godt oplyst rum.\nHold sporingskameraerne fri, og vend dig mod møbler eller andre synlige detaljer. + Stadig fast? På din telefon: smarte briller → Sporing → Åbn opsætning → Vis diagnostik → Genstart sporing. + Smart-briller afbrudt + Tjek USB-forbindelsen, og tilslut smartbrillerne igen.\nAccepter USB-adgangsprompten på din telefon, hvis den vises. + Når du er tilsluttet, skal du se dig langsomt omkring i et godt oplyst rum for at genoprette sporingen. + Centrering er nødvendig + Sporingen er vendt tilbage i en ny position.\nSe fremad, og tryk derefter på nulstil sporingscenter på din telefon. + Du kan også finde nulstilling af sporingscenter i smartbriller → Sporing → Åbn opsætning. Din gemte kamerakalibrering gemmes. + Hold stille et øjeblik + Nulstilling af sporingscenter er i gang.\nHold smartbrillerne stabile, mens sporingen stabiliseres. + Denne skærm lukker automatisk, når hovedsporing er klar. + Stabiliseret sigte med hænderne + Sigt fra din skulder gennem din håndflade. Slå denne indstilling fra for håndledsstyret rotation. + Rumlig opsætning + Venter på sporing... + Venstre og højre sporingskamera + Kamerasynkronisering + Klar + Venter på, at kamera og hovedsporing er på linje. Hold de smarte briller forbundet. + 1. Forbered kalibreringsmålet + Udskriv i faktisk størrelse + Hver firkant skal måle 30 mm (1.181 in). Monter pladen fladt på en stiv overflade i et godt oplyst område. + Udskriv kalibreringsmønster + 2. Optag forskellige visninger + Hold kalibreringsmålet stationært + Flyt de smarte briller tættere på, længere og sidelæns. Drej dem til venstre/højre, vinkle dem op/ned, og vip dem til siden. Behold kalibreringsmålet i begge kameraer, og hold en kort pause før hver optagelse. + Start ny kalibrering + Venter på kamerasynkronisering. + Start en ny kalibrering for at indsamle visninger. + Hold kalibreringsmålet synligt i begge forhåndsvisninger. Optag mindst 24 skarpe billeder fra forskellige vinkler. + Optager... + Optag kalibreringsmålvisning + Beregn kamerajustering + Beregner... + Beregn kalibrering + 3. Kontroller afstanden + Målt afstand + Start med 12 tommer eller 30 cm, så de trykte markører er nemmere at opdage. Vælg den nøjagtige måling, du vil bruge. + Venstre kamera til kalibreringsmålcenter + Kontrollerer afstand... + Valider afstand + Diagnostik + Vis diagnostik + Værktøjer til gendannelse af kameratiming og sporing. + Kameratiming + Input fra sporing af hænder + Venter på kameratiming. + Kamerabilleder + GPU-detektering af hænder + CPU er standard. GPU er eksperimentel og kan få SteamVR til at genstarte. Dette valg nulstilles, når sporingen genstartes. + Lite-detektion af håndmodeller + Brug Lite håndfladedetektor og Lite nøglepunkter på hænderne. Tjek sigte-, klem- og grebsnøjagtighed. Nulstiller, når sporing genstartes. + Automatisk indgangsfrekvens til sporing af hænder + Juster input til behandlingshastighed. Nulstiller, når sporing genstartes. + Begræns inputfrekvens for sporing af hænder + Brug halvdelen af kamerabillederne. Sluk for at sammenligne den maksimale frekvens. Nulstiller, når sporing genstartes. + Diagnostisk optagelse + Gem ét stereobilledpar lokalt. Billeder gemmes kun efter anmodning. + Gem kamerabillede + Genstart sporing + Bruges, hvis sporingen ikke genoprettes i et godt oplyst område. En genstart kræver en ny sporingsoprindelse. + Genstart + Genstart sporing? + Ikke-gemte kalibreringsvisninger vil gå tabt. Hold smartbrillerne stille bagefter, og nulstil sporingscenteret, når sporingen er genoprettet. + %1$d / 24 visninger taget + Optagelse sat på pause: %1$s + Mål %1$s. Vis det komplette kalibreringsmål i begge forhåndsvisninger, og hold derefter stille. + %1$.1f Hz • billedalder %2$.1f ms • behandler %3$.1f ms + Inputgrænse %1$.1f Hz • %2$.0f%% for kamerabilleder. Hovedsporing fortsætter ved sin maksimale frekvens. + %1$d behandlet • %2$d droppet • %3$d sprunget over af inputgrænse + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra kalibrering + Udskriv ved 100% / faktisk størrelse. Hver firkant: 30 mm (1.181 tommer). + Hold kalibreringsmålet fladt og stationært; flyt de smarte briller mellem optagelserne. + Skalakontrol: 100 mm (3.937 in) mellem kryds + 12 tommer (30,48 cm) + 30 cm (11,81 tommer) + 20 tommer (50,8 cm) + 50 cm (19,69 tommer) + Deaktiveret + Venter på stabil sporing + Afbrudt + Controllere, der betjenes med bare hænder, er slukket + Positionssporing er slået fra, eller smartbriller er afbrudt + Nulstilling af sporingscenter anmodes — hold stille, mens sporingen stabiliserer sig. + Sporing er gået tabt – vend ind mod et godt oplyst område med synlige detaljer + Sporingsoprindelse ændret — tryk på nulstil sporingscenter, og hold derefter stille. + 6DoF aktiv + Tilslut Luma Ultra og aktiver positionssporing. + Kalibrering verificeret for denne forbindelse. + Kalibrering verificeret og gemt. + Venter på stereokameraer + Venter på sporing af hænder + Hold 5 × 7 kalibreringsmålet stationært. Optag 24+ visninger, mens du flytter og roterer de smarte briller. + Venter på det næste kamerabillede. Hold de smarte briller stille. + Kontrollerer det næste kamerabillede. Hold hele kalibreringsmålet synligt, og hold det stille. + Start kalibreringen først + Intet nyt kamerabillede ankom. Tjek forbindelsen til smarte briller og forhåndsvisninger af kameraet, og prøv derefter igen. + Nulstilling af kameraur + Sporingskoordinatsystem ændret. Dine visninger gemmes til genberegning. Nulstil sporingscenter, og start derefter et nyt sæt for at optage flere visninger. + enhedskalibrering indlæst + Luma Ultra base kalibrering indlæst + kalibrering påkrævet + Tryk på Start ny kalibrering først. + Nulstil sporingscenter venter på stabil sporing. Hold stille et øjeblik. + Sporing ændret. Tryk på nulstil sporingscenter én gang, og hold derefter stille, før du optager. + Optagelse afvist: Hovedsporingen var ikke synkroniseret, eller den ændrede sig under optagelsen. Hold stille og prøv igen. + Beregn kamerajustering, før du kontrollerer afstanden. + kamerabehandling mislykkedes + Hovedsporing ændret under registrering af hænder + Venter på kamera- og hovedsynkronisering + Ingen håndled opdaget. Hold dine Joy-Con-controllerhåndtag foran de smarte briller + Ingen hænder fundet. Vis åbne håndflader foran de smarte briller + Håndled synlige i kun ét kamera; hold dine controllerhåndtag i den delte visning + Hænderne er kun synlige i ét kamera; hold begge håndflader i den delte visning + Begge kameraer ser hænder, men venstre/højre-matchning er tvetydig + Hænder registreret, men stereodybden er inkonsekvent + Håndledsposition afvist af stereo- eller bevægelsestjek + Stereopunkter registreret, men palmegeometrien er inkonsekvent + Fuldfør kalibrering og afstandskontrol for at aktivere hænder + Venter på stabil hovedsporing; nulstil sporingscenter, hvis det anmodes om. + Kameraobservation er for gammel; venter på et nyt par + Tilpas %1$.2f px. Mål din valgte afstand fra venstre kamera til kalibreringsmålets centrum, og valider derefter. + OpenCV utilgængelig: %1$s + %1$d gemte visninger gendannet. Beregn kalibrering for at prøve igen, eller start et nyt sæt for at fange mere. + Optaget %1$d / 24 visninger. Hold kalibreringsmålet fast; flyt de smarte briller til næste visning. + Optagelse afvist: %1$d / 12 påkrævede hjørner synlige i begge kameraer. Vis mere af kalibreringsmålet, hold stille, og prøv derefter igen. + Afstandskontrol kunne ikke afsluttes: %1$s. Prøv igen. + Registrering af hænder utilgængelig: %1$s. Skift CPU/GPU eller skift controllere betjent med bare hænder for at prøve igen. + Registrering af hænder overskredet %1$d ms; observation forkastet + %1$d / 2 Joy-Con håndledspositioner målt ved stereo + Håndflader sporet: %1$d / 2; knibebevægelse klar: %2$d; gribebevægelse klar: %3$d + Gemt diagnostisk optagelse i %1$s + Sporing af hænder stoppet: %1$s + Stereo %1$d×%2$d; %3$s + Hovedsporing og kalibreringsmålet er uenige med %1$s (grænse 5 cm / 2 in). Hold kalibreringsmålet fast, og vent på konstant sporing, før du starter et nyt sæt. Drej og vip de smarte briller forsigtigt; pause før hver optagelse. + Optag mindst 24 forskellige visninger af det stationære kalibreringsmål. + Drej de smarte briller til venstre og højre, og vip dem op og ned; bevægelse uden rotation kan ikke kalibrere kamerajustering. + Usandsynlig kameragrundlinje + Bevæg dit hoved gennem mere varierede orienteringer. + Ugyldig kamera-til-hoved-rotation + Kamera-til-hoved justering er inkonsekvent. + Kalibrering kunne ikke afsluttes. %1$s Dine optagne visninger gemmes. + Udholdt reprojektionsfejl %1$.2f px overstiger 2 px. Kalibrer igen. + %1$d / 24 skakternet hjørner registreret i begge kameraer. Hold hele kalibreringsmålet synligt, og hold det stille. Hvis det allerede er synligt, skal du vælge 12 tommer eller 30 cm og måle den tættere afstand, før du prøver igen. + Kalibreringsmålet er synligt, men dets dybde kunne ikke måles pålideligt. Hold de smarte briller stille og hold kalibreringsmålet fladt og godt oplyst, og prøv derefter igen. + Kameramålingen var ugyldig. Hold stille og prøv igen. + Afstandskontrol bestået. + Kontroller igen afstanden fra venstre kamera til kalibreringsmålets centrum, og prøv derefter igen. + Kameraer målt %1$s; valgt afstand %2$s. %3$s + Vent på forhåndsvisning af begge kameraer, før du starter kalibreringen. + Gemte visninger kan genberegnes. Start en ny kalibrering for at fange i det aktuelle sporingskoordinatsystem. + Håndmodel kontrolsum uoverensstemmelse + OpenCV kunne ikke indlæse diff --git a/app/src/main/res/values-de/strings.xml b/app/src/main/res/values-de/strings.xml index 7552cce411..dfaa30fed7 100644 --- a/app/src/main/res/values-de/strings.xml +++ b/app/src/main/res/values-de/strings.xml @@ -2352,14 +2352,14 @@ Anzeige Bildwiederholrate 3D (Side-by-Side) - Jedes Auge bekommt seine eigene Hälfte eines 3840×1080-Bildes. Fällt das Bild aus, halte die 2D/3D-Taste der Brille gedrückt. + Schalten Sie die Datenbrille auf Side-by-Side-3D um. Das Headtracking wird separat gesteuert. Das 3D-Signal wurde nicht bestätigt. Versuche es erneut, sobald das 2D-Bild wieder da ist. Kein Bild: Die Brille ist in einem Modus, den dieses Smartphone nicht ausgeben kann. Halte ihre 2D/3D-Taste gedrückt oder steck sie aus und wieder ein. 3D-Bildwiederholrate 3D für VR-Spiele Wechselt zu 3D, solange SteamVR läuft, und danach zurück. - 3D-Bild - Automatisch: SteamVR füllt die Sicht; andere Spiele schweben in 3D als Bildschirm und bleiben in 2D flach. + Bild + Automatisch zeigt flache Inhalte in beiden Augen an und erkennt SteamVR. Wählen Sie „Side-by-Side-Spiel“ für SBS-Inhalte. Automatisch Virtueller Bildschirm Side-by-Side-Spiel @@ -2369,20 +2369,20 @@ Diese Einstellungen gelten, solange „Spiel auf der Brille“ aktiviert ist und das Spiel dort angezeigt wird. „Automatisch“ zeigt dieses 2D-Spiel im Vollbild. Nutze einen virtuellen Bildschirm, um Breite, Abstand und Kopf-Tracking anzupassen. Virtuellen Bildschirm nutzen - SteamVR füllt die Sicht. Passe unten das Sichtfeld an; Breite und Abstand gelten nur für einen virtuellen Bildschirm. + SteamVR füllt die Ansicht. Passen Sie das Sichtfeld in VR an. Breite und Abstand gelten nur für einen virtuellen Bildschirm. Side-by-Side-Spiele füllen jedes Auge. Breite und Abstand gelten nur für einen virtuellen Bildschirm. „Automatisch“ hält dieses 2D-Spiel fest im Blickfeld. Wähle unter „Anzeige“ die Option „Virtueller Bildschirm“, um Kopf-Tracking zu nutzen. Kopf-Tracking gilt für einen virtuellen Bildschirm oder ein laufendes SteamVR-Spiel. - Brille + Gerät Helligkeit Lautstärke Sonnenschutz Dunkelt die vorderen Gläser ab. - Kopf-Tracking + Verfolgung Kopf-Tracking Die eigenen Sensoren der Brille drehen den virtuellen Bildschirm und SteamVR mit deinem Kopf mit. Ansicht zentrieren - Zentrieren + Bildschirm neu zentrieren SteamVR-Sichtfeld Niedriger holt SteamVR näher heran und füllt die Brille; höher zeigt mehr von deiner Umgebung. Spiel läuft auf %1$s @@ -2403,8 +2403,8 @@ Gespeicherte Kalibrierung entfernen und die Standardwerte des Modells wiederherstellen? Zentriere die Ansicht, nachdem du die Brille wieder aufgesetzt hast. Zurücksetzen Hand-Tracking - Deine Hände mit der Kamera verfolgen? - Die Kamera sieht deine Hände. Ist kein Controller verbunden, werden deine bloßen Hände zu den VR-Händen: Daumen und Zeigefinger zusammendrücken zum Klicken, die Hand schließen zum Greifen, und für das Menü die Handfläche zu dir drehen und zusammendrücken. Mit Joy-Cons setzt sie sie dorthin, wo deine Hände wirklich sind. Bilder werden auf diesem Gerät verarbeitet und nie gespeichert oder gesendet. + Hände oder Joy-Con-Controller mit der Telefonkamera verfolgen? + Wenn kein Controller angeschlossen ist, verfolgt die Telefonkamera Ihre bloßen Hände in VR: Drücken Sie Daumen und Zeigefinger, um zu klicken, schließen Sie Ihre Hand, um zu greifen, und drehen Sie Ihre Handfläche in Ihre Richtung und drücken Sie, um das Menü zu öffnen. Bei gekoppelten Joy-Con-Controllern verfolgt die Kamera ihre Position, während die Joy-Con-Controller Drehungen und Tasteneingaben ermöglichen. Bilder werden auf diesem Gerät verarbeitet und niemals gespeichert oder gesendet. Rückkamera Empfohlen. Meist schärfer und weitwinkliger. Frontkamera @@ -2412,7 +2412,7 @@ Kamera verwenden Nicht jetzt Hand-Tracking per Kamera - Ist kein Controller verbunden, werden deine Hände zu den VR-Händen: zusammendrücken zum Klicken, Handfläche zu dir und zusammendrücken für das Menü. Mit Joy-Cons platziert sie diese dort, wo die Kamera sie sieht. Bilder bleiben auf diesem Gerät. + Verwenden Sie die Smartphone-Kamera für Gesten mit bloßen Händen oder zur Positionierung gekoppelter Joy-Con-Controller in VR. Die Joy-Con-Controller ermöglichen Drehung und Tasteneingaben. Die Verfolgung wird pausiert, während die Smartbrille Ihre Hände oder Joy-Con-Controller verfolgt. Bilder werden nur auf diesem Gerät verarbeitet. Kamera Kamerazugriff Erlaube den Kamerazugriff, damit das Hand-Tracking starten kann. @@ -2680,4 +2680,208 @@ %1$s wird für Steam umgewandelt. DroidDeck geöffnet lassen. Dieses Gerät kann das Video nicht dekodieren. Das Video konnte nicht importiert werden + Luma Ultra-Kameras – Experimentell + Joy-Con-Positionsverfolgung + Positionieren Sie Ihre gekoppelten Joy-Con-Controller mithilfe der Kameras Ihrer Smartbrille. Drehung und Tasteneingaben erfolgen über die Joy-Con-Controller. Die Position wird geschätzt, wenn Ihre Handgelenke verdeckt sind. Ersetzt Controller, die mit bloßen Händen bedient werden, und pausiert die Verfolgung per Smartphone-Kamera. Richten Sie die Joy-Con-Controller nach vorn, wenn Sie die Verbindung herstellen oder das Tracking-Center zurücksetzen. + Aktivieren Sie zuerst die Positionsverfolgung. Erfordert bewegungsfähige Joy-Con-Controller auf Android 12 oder höher. Standardmäßig deaktiviert. + Intelligente Brille + Anzeige- und Head-Tracking-Einstellungen werden in allen DroidDeck-Menüs, Spielen und Desktop-Sitzungen gemeinsam genutzt. + Schließen Sie Datenbrillen an, um deren Anzeige- und Tracking-Einstellungen zu ändern. Ihre gespeicherten Einstellungen bleiben erhalten, wenn Sie die Verbindung trennen. + VR + Anzeigemodus + 2D-Ausgabe + 3D-Ausgabe + Bild und virtueller Bildschirm + Position und Bodenhöhe + Verfolgung von Händen – Experimentell + Tracking-Status + 2D-Auflösung + 3D-Auflösung + VR-Auflösung + Automatisch + Identisch mit 2D/3D + Ausgabeauflösung pro Auge. + Aktivieren Sie „Spiel auf Smart Glasses“, um den nativen 30-Hz-Modus des Displays auszuwählen. + Virtueller 3DoF-Bildschirm + Verankern Sie flache Spiele vor sich, damit Sie sich umschauen können. Ermöglicht das Spielen auf Smart Glasses, ohne auf 3D umzuschalten. + Breite und Abstand aktualisieren den verfolgten virtuellen Bildschirm für DroidDeck-Menüs, Spiele und Desktop-Sitzungen sofort. + Die Positionsverfolgung umfasst die Kopfrotation in SteamVR. Für eine reine Rotationsverfolgung schalten Sie die Positionsverfolgung aus. + Steuert die Kopfbewegung auf dem virtuellen Bildschirm. Die Positionsverfolgung umfasst die Kopfdrehung in SteamVR. + Schnelle Aktionen + Richten Sie Ihren Blick auf die gewünschte Position des Bildschirms und setzen Sie anschließend das Tracking-Center zurück, um Höhe und Ausrichtung festzulegen. + Joy-Con neu zentrieren + Telefonkamera – Experimentell + Track-Hände oder Joy-Con-Controller + 6DoF virtueller Bildschirm + Positionsverfolgung – experimentell + Physische Bewegung in VR und auf virtuellen Bildschirmen. Der Neustart des Trackings dauert einen Moment. + Aktuelle Augenhöhe über dem Boden + Bodenhöhe ausgehend von der aktuellen Höhe einstellen + Bodenniveau einstellen + Einrichtung und Diagnose der Stereokamera + Überprüfen Sie vor dem Spielen die Kamerakalibrierung und das Tracking der Hände. + Setup öffnen + Controller werden mit bloßen Händen bedient + Verwenden Sie die Smart-Brillen-Kameras, um mit Ihren Händen zu zielen, drücken Sie, um zu klicken, und schließen Sie Ihre Hand, um in VR zu greifen. Gamepad-Sticks bewegen und drehen sich. Ersetzt die Joy-Con-Positionsverfolgung. Während des Spielens kann es zu Verzögerungen oder Trackingverlusten kommen. + Aktivieren Sie Controller, die mit bloßen Händen unter Luma Ultra-Kameras in Tracking bedient werden. Zeigen Sie zuerst offene Hände. + Gemeinsame Luma Ultra-Kalibrierung + Verwendung der gemeinsamen Luma Ultra-Basis. Kalibrieren Sie Ihre eigene Datenbrille, um deren Genauigkeit zu überprüfen. + Gemessene Kalibrierung verifiziert + Validierung erforderlich + Controller, die mit bloßen Händen bedient werden, werden verfügbar, nachdem die gemessene Distanzprüfung bestanden wurde. + Tracking verloren + Schauen Sie sich langsam in einem gut beleuchteten Raum um.\nHalten Sie die Tracking-Kameras frei und blicken Sie auf Möbel oder andere sichtbare Details. + Immer noch nicht weitergekommen? Auf Ihrem Telefon: Datenbrille → Tracking → Setup öffnen → Diagnose anzeigen → Tracking neu starten. + Datenbrille getrennt + Überprüfen Sie die USB-Verbindung und schließen Sie die Datenbrille erneut an.\nAkzeptieren Sie die USB-Zugriffsaufforderung auf Ihrem Telefon, falls diese angezeigt wird. + Sobald die Verbindung hergestellt ist, schauen Sie sich langsam in einem gut beleuchteten Raum um, um die Ortung wiederherzustellen. + Neuzentrierung erforderlich + Die Verfolgung wurde in einer neuen Position fortgesetzt.\nBlicken Sie nach vorn und tippen Sie anschließend auf Ihrem Smartphone auf „Tracking-Center zurücksetzen“. + Sie können das Tracking-Zentrum auch unter Smart Glasses → Tracking → Einstellungen öffnen zurücksetzen. Ihre gespeicherte Kamerakalibrierung bleibt erhalten. + Halten Sie einen Moment still + Das Zurücksetzen des Tracking-Zentrums wird durchgeführt.\nHalten Sie die Smart Glasses ruhig, bis sich das Tracking stabilisiert hat. + Dieser Bildschirm wird automatisch geschlossen, wenn die Kopfverfolgung bereit ist. + Stabilisiertes Zielen mit den Händen + Zielen Sie von Ihrer Schulter durch Ihre Handfläche. Ausschalten für handgelenkgesteuerte Drehung. + Räumliche Einrichtung + Warten auf Tracking… + Linke und rechte Trackingkameras + Kamerasynchronisation + Fertig + Warten auf die Ausrichtung von Kamera und Head-Tracking. Halten Sie die Datenbrille verbunden. + 1. Bereiten Sie das Kalibrierungsziel vor + Drucken in Originalgröße + Jedes Quadrat muss 30 mm (1,181 Zoll) messen. Montieren Sie die Platte flach auf einer festen Oberfläche an einem gut beleuchteten Ort. + Kalibrierungsmuster drucken + 2. Erfassen Sie verschiedene Ansichten + Halten Sie das Kalibrierungsziel stationär + Bewegen Sie die Datenbrille näher, weiter und seitwärts. Drehen Sie sie nach links/rechts, neigen Sie sie nach oben/unten und neigen Sie sie zur Seite. Behalten Sie das Kalibrierungsziel in beiden Kameras bei und halten Sie vor jeder Aufnahme kurz inne. + Neue Kalibrierung starten + Warten auf Kamerasynchronisation. + Starten Sie eine neue Kalibrierung, um Ansichten zu sammeln. + Lassen Sie das Kalibrierungsziel in beiden Vorschauen sichtbar. Nehmen Sie mindestens 24 scharfe Ansichten aus verschiedenen Blickwinkeln auf. + Aufnahme... + Kalibrierungszielansicht erfassen + Kameraausrichtung berechnen + Berechnen… + Kalibrierung berechnen + 3. Überprüfen Sie den Abstand + Gemessene Distanz + Beginnen Sie mit 12 Zoll oder 30 cm, damit die gedruckten Markierungen leichter zu erkennen sind. Wählen Sie das genaue Maß, das Sie verwenden möchten. + Linke Kamera zur Kalibrierungszielmitte + Abstand prüfen… + Distanz validieren + Diagnose + Diagnose anzeigen + Tools zur Kamera-Timing- und Tracking-Wiederherstellung. + Kamera-Timing + Eingabe aus der Handverfolgung + Warten auf Kamera-Timing. + Kamerabilder + GPU-Erkennung von Händen + CPU ist die Standardeinstellung. Die GPU ist experimentell und kann einen Neustart von SteamVR verursachen. Diese Auswahl wird zurückgesetzt, wenn die Verfolgung neu gestartet wird. + Lite-Erkennung von Handmodellen + Verwenden Sie den Lite-Handflächendetektor und die Lite-Schlüsselpunkte an den Händen. Überprüfen Sie die Ziel-, Klemm- und Greifgenauigkeit. Wird beim Neustart der Verfolgung zurückgesetzt. + Automatische Eingabefrequenz für die Handverfolgung + Passen Sie die Eingabe an die Verarbeitungsgeschwindigkeit an. Wird beim Neustart der Verfolgung zurückgesetzt. + Eingangsfrequenz für die Handverfolgung begrenzen + Verwenden Sie die Hälfte der Kamerabilder. Schalten Sie diese Option aus, um die maximale Frequenz zu vergleichen. Wird beim Neustart der Verfolgung zurückgesetzt. + Diagnoseerfassung + Speichern Sie ein Stereobildpaar lokal. Bilder werden nur auf Anfrage gespeichert. + Kamerabild speichern + Tracking neu starten + Verwenden Sie diese Option, wenn die Verfolgung in einem gut beleuchteten Bereich nicht wiederhergestellt werden kann. Ein Neustart erfordert einen neuen Tracking-Ursprung. + Neustart + Tracking neu starten? + Nicht gespeicherte Kalibrierungsansichten gehen verloren. Halten Sie die Smart Glasses anschließend ruhig und setzen Sie das Tracking-Zentrum zurück, sobald das Tracking wiederhergestellt ist. + %1$d / 24 Aufrufe erfasst + Aufnahme angehalten: %1$s + Messen Sie %1$s. Zeigen Sie das vollständige Kalibrierungsziel in beiden Vorschauen an und halten Sie dann still. + %1$.1f Hz • Bildalter %2$.1f ms • Verarbeitung %3$.1f ms + Eingabegrenze %1$.1f Hz • %2$.0f%% der Kamerabilder. Die Kopfverfolgung wird mit maximaler Frequenz fortgesetzt. + %1$d verarbeitet • %2$d gelöscht • %3$d durch Eingabelimit übersprungen + DroidDeck ChArUco 30 mm + DroidDeck – Luma Ultra-Kalibrierung + Drucken mit 100 % / Tatsächliche Größe. Jedes Quadrat: 30 mm (1,181 Zoll). + Halten Sie das Kalibrierungsziel flach und stationär; Bewegen Sie die Datenbrille zwischen den Aufnahmen. + Maßstabsprüfung: 100 mm (3,937 Zoll) zwischen den Teilstrichen + 12 Zoll (30,48 cm) + 30 cm (11,81 Zoll) + 20 Zoll (50,8 cm) + 50 cm (19,69 Zoll) + Deaktiviert + Warten auf stabiles Tracking + Nicht verbunden + Mit bloßen Händen bediente Controller sind ausgeschaltet + Die Positionsverfolgung ist ausgeschaltet oder die Datenbrille ist nicht angeschlossen + Zurücksetzen des Tracking-Zentrums angefordert – halten Sie die Smart Glasses ruhig, bis sich das Tracking stabilisiert hat. + Tracking verloren – richten Sie Ihren Blick auf einen gut beleuchteten Bereich mit sichtbaren Details + Tracking-Ursprung geändert – tippen Sie auf „Tracking-Zentrum zurücksetzen“ und halten Sie die Smart Glasses ruhig. + 6DoF aktiv + Luma Ultra anschließen und Positionsverfolgung aktivieren. + Kalibrierung für diese Verbindung überprüft. + Kalibrierung überprüft und gespeichert. + Warten auf Stereokameras + Warten auf die Ortung der Hände + Halten Sie das 5 × 7-Kalibrierungsziel stationär. Erfassen Sie mehr als 24 Ansichten, während Sie die Datenbrille bewegen und drehen. + Warten auf das nächste Kamerabild. Halten Sie die Datenbrille ruhig. + Überprüfen des nächsten Kamerabildes. Halten Sie das vollständige Kalibrierungsziel sichtbar und halten Sie es ruhig. + Starten Sie zuerst die Kalibrierung + Es ist kein neues Kamerabild eingetroffen. Überprüfen Sie die Datenbrillenverbindung und die Kameravorschau und versuchen Sie es dann erneut. + Kamerauhr zurückgesetzt + Tracking-Koordinatensystem geändert. Ihre Ansichten werden zur Neuberechnung gespeichert. Setzen Sie das Tracking-Zentrum zurück und starten Sie dann eine neue Aufnahme, um weitere Ansichten zu erfassen. + Gerätekalibrierung geladen + Luma Ultra-Basiskalibrierung geladen + Kalibrierung erforderlich + Tippen Sie auf „Zuerst neue Kalibrierung starten“. + Das Zurücksetzen des Tracking-Zentrums wartet auf stabiles Tracking. Halten Sie die Smart Glasses kurz ruhig. + Tracking geändert. Tippen Sie einmal auf „Tracking-Zentrum zurücksetzen“ und halten Sie die Smart Glasses vor der Aufnahme ruhig. + Aufnahme abgelehnt: Die Kopfverfolgung war nicht synchron oder hat sich während der Aufnahme geändert. Halten Sie still und versuchen Sie es erneut. + Berechnen Sie die Kameraausrichtung, bevor Sie den Abstand überprüfen. + Kameraverarbeitung fehlgeschlagen + Die Kopfverfolgung wurde während der Handerkennung geändert + Warten auf Kamera- und Kopfsynchronisation + Keine Handgelenke erkannt. Halten Sie die Griffe Ihres Joy-Con-Controllers vor der Datenbrille + Keine Hände erkannt. Zeigen Sie offene Handflächen vor der Datenbrille + Handgelenke nur in einer Kamera sichtbar; Behalten Sie Ihre Controller-Handles in der freigegebenen Ansicht + Hände nur in einer Kamera sichtbar; Halten Sie beide Handflächen im gemeinsamen Blickfeld + Beide Kameras sehen Hände, aber die Links/Rechts-Zuordnung ist nicht eindeutig + Hände erkannt, aber die Stereotiefe ist inkonsistent + Handgelenksposition wurde durch Stereo- oder Bewegungsprüfungen abgelehnt + Stereopunkte erkannt, aber die Handflächengeometrie ist inkonsistent + Schließen Sie die Kalibrierung und die Distanzprüfung ab, um die Hände freizugeben + Warten auf stabiles Head-Tracking; Tracking-Zentrum bei Bedarf zurücksetzen. + Kamerabeobachtung ist zu alt; warte auf ein neues Paar + %1$.2f px anpassen. Messen Sie den ausgewählten Abstand von der linken Kamera zum Zentrum des Kalibrierungsziels und bestätigen Sie ihn anschließend. + OpenCV nicht verfügbar: %1$s + %1$d gespeicherte Ansichten wiederhergestellt. Berechnen Sie die Kalibrierung, um es erneut zu versuchen, oder starten Sie einen neuen Satz, um mehr zu erfassen. + Aufgenommen %1$d / 24 Aufrufe. Halten Sie das Kalibrierungsziel fest; Bewegen Sie die Datenbrille für die nächste Ansicht. + Aufnahme abgelehnt: %1$d / 12 erforderliche Ecken in beiden Kameras sichtbar. Zeigen Sie mehr vom Kalibrierungsziel, halten Sie still und versuchen Sie es dann erneut. + Entfernungsprüfung konnte nicht abgeschlossen werden: %1$s. Versuchen Sie es erneut. + Handerkennung nicht verfügbar: %1$s. Wechseln Sie CPU/GPU oder schalten Sie mit bloßen Händen bediente Controller um, um es erneut zu versuchen. + Erkennung von Händen überschreitet %1$d ms; Beobachtung verworfen + %1$d / 2 Joy-Con-Handgelenkspositionen, gemessen per Stereo + Verfolgte Handflächen: %1$d / 2; Pinch bereit: %2$d; Greifen bereit: %3$d + Diagnoseerfassung gespeichert unter %1$s + Handverfolgung gestoppt: %1$s + Stereo %1$d×%2$d; %3$s + Head-Tracking und das Kalibrierungsziel stimmen um %1$s nicht überein (Grenzwert 5 cm / 2 Zoll). Halten Sie das Kalibrierungsziel fixiert und warten Sie auf eine stabile Verfolgung, bevor Sie mit einem neuen Satz beginnen. Drehen und neigen Sie die Datenbrille vorsichtig; Machen Sie vor jeder Aufnahme eine Pause. + Erfassen Sie mindestens 24 verschiedene Ansichten des stationären Kalibrierungsziels. + Drehen Sie die Datenbrille nach links und rechts und neigen Sie sie nach oben und unten. Eine Bewegung ohne Drehung kann die Kameraausrichtung nicht kalibrieren. + Unplausible Kamerabasislinie + Bewegen Sie Ihren Kopf durch verschiedene Ausrichtungen. + Ungültige Kamera-zu-Kopf-Rotation + Die Ausrichtung der Kamera zum Kopf ist inkonsistent. + Die Kalibrierung konnte nicht abgeschlossen werden. %1$s Ihre erfassten Ansichten werden gespeichert. + Reprojektionsfehler bei der Validierung %1$.2f px überschreitet 2 px. Neu kalibrieren. + %1$d / 24 Schachbrettecken in beiden Kameras erkannt. Halten Sie das vollständige Kalibrierungsziel sichtbar und halten Sie es ruhig. Wenn es bereits sichtbar ist, wählen Sie 12 Zoll oder 30 cm und messen Sie den näheren Abstand, bevor Sie es erneut versuchen. + Das Kalibrierungsziel ist sichtbar, seine Tiefe konnte jedoch nicht zuverlässig gemessen werden. Halten Sie die Datenbrille ruhig und halten Sie das Kalibrierungsziel flach und gut beleuchtet. Versuchen Sie es dann erneut. + Die Kameramessung war ungültig. Halten Sie still und versuchen Sie es erneut. + Distanzprüfung bestanden. + Überprüfen Sie den Abstand von der linken Kamera zur Mitte des Kalibrierungsziels erneut und versuchen Sie es dann erneut. + Kameras gemessen %1$s; ausgewählte Entfernung %2$s. %3$s + Warten Sie auf die Vorschau beider Kameras, bevor Sie mit der Kalibrierung beginnen. + Gespeicherte Ansichten können neu berechnet werden. Starten Sie eine neue Kalibrierung zur Erfassung im aktuellen Tracking-Koordinatensystem. + Die Prüfsumme des Handmodells stimmt nicht überein + OpenCV konnte nicht geladen werden diff --git a/app/src/main/res/values-el/strings.xml b/app/src/main/res/values-el/strings.xml index 01a89d686b..bb3ed78302 100644 --- a/app/src/main/res/values-el/strings.xml +++ b/app/src/main/res/values-el/strings.xml @@ -2366,14 +2366,14 @@ Οθόνη Ρυθμός ανανέωσης 3D (δίπλα-δίπλα) - Κάθε μάτι παίρνει το δικό του μισό μιας εικόνας 3840×1080. Αν η εικόνα χαθεί, κρατήστε πατημένο το κουμπί 2D/3D των γυαλιών. + Αλλάξτε τα έξυπνα γυαλιά σε 3D δίπλα-δίπλα. Η παρακολούθηση κεφαλιού ελέγχεται ξεχωριστά. Το σήμα 3D δεν επιβεβαιώθηκε. Δοκιμάστε ξανά μόλις επανέλθει η εικόνα 2D. Δεν υπάρχει εικόνα: τα γυαλιά είναι σε λειτουργία που αυτό το τηλέφωνο δεν μπορεί να στείλει. Κρατήστε πατημένο το κουμπί 2D/3D τους ή αποσυνδέστε τα και συνδέστε τα ξανά. Ρυθμός ανανέωσης 3D 3D για παιχνίδια VR Μεταβαίνει σε 3D όσο εκτελείται το SteamVR και επιστρέφει μετά. - Εικόνα 3D - Αυτόματο: το SteamVR γεμίζει το οπτικό πεδίο· τα άλλα παιχνίδια αιωρούνται ως οθόνη στο 3D και μένουν επίπεδα στο 2D. + Εικόνα + Εμφανίζει αυτόματα επίπεδο περιεχόμενο και στα δύο μάτια και ανιχνεύει το SteamVR. Επιλέξτε Side-by-side game για περιεχόμενο SBS. Αυτόματο Εικονική οθόνη Παιχνίδι δίπλα-δίπλα @@ -2383,20 +2383,20 @@ Αυτές οι ρυθμίσεις ισχύουν όσο είναι ενεργό το «Παιχνίδι στα γυαλιά» και το παιχνίδι εμφανίζεται εκεί. Το «Αυτόματο» κρατά αυτό το παιχνίδι 2D σε πλήρη οθόνη. Χρησιμοποιήστε εικονική οθόνη για να ρυθμίσετε το πλάτος, την απόσταση και την παρακολούθηση κεφαλιού. Χρήση εικονικής οθόνης - Το SteamVR γεμίζει όλη την εικόνα. Ρυθμίστε το οπτικό του πεδίο παρακάτω· το πλάτος και η απόσταση ισχύουν μόνο για εικονική οθόνη. + Το SteamVR γεμίζει την προβολή. Προσαρμόστε το οπτικό του πεδίο στο VR. Το πλάτος και η απόσταση ισχύουν μόνο για μια εικονική οθόνη. Τα παιχνίδια δίπλα-δίπλα γεμίζουν το πεδίο κάθε ματιού. Το πλάτος και η απόσταση ισχύουν μόνο για εικονική οθόνη. Το «Αυτόματο» κρατά αυτό το παιχνίδι 2D σταθερό στο οπτικό πεδίο. Επιλέξτε «Εικονική οθόνη» στην ενότητα «Οθόνη» για να χρησιμοποιήσετε παρακολούθηση κεφαλιού. Η παρακολούθηση κεφαλιού ισχύει για εικονική οθόνη ή για παιχνίδι SteamVR που εκτελείται. - Γυαλιά + Συσκευή Φωτεινότητα Ένταση ήχου Σκίαση Σκουραίνει τους μπροστινούς φακούς. - Παρακολούθηση κεφαλιού + Παρακολούθηση Παρακολούθηση κεφαλιού Οι αισθητήρες των ίδιων των γυαλιών περιστρέφουν την εικονική οθόνη και το SteamVR μαζί με το κεφάλι σας. Επανακεντράρισμα προβολής - Επανακεντράρισμα + Επανακεντράρισμα οθόνης Οπτικό πεδίο SteamVR Χαμηλότερο: το SteamVR έρχεται πιο κοντά και γεμίζει τα γυαλιά· υψηλότερο: βλέπετε περισσότερα γύρω σας. Παίζετε στα %1$s @@ -2417,8 +2417,8 @@ Να καταργηθεί η αποθηκευμένη βαθμονόμηση και να επανέλθουν οι προεπιλογές του μοντέλου; Κάντε επανακεντράρισμα αφού φορέσετε ξανά τα γυαλιά. Επαναφορά Παρακολούθηση χεριών - Να παρακολουθούνται τα χέρια σας με την κάμερα; - Η κάμερα μπορεί να δει τα χέρια σας. Χωρίς συνδεδεμένο χειριστήριο, τα γυμνά χέρια σας γίνονται τα χέρια VR: ενώστε τον αντίχειρα με τον δείκτη για κλικ, κλείστε το χέρι για να πιάσετε, και για το μενού γυρίστε την παλάμη προς το μέρος σας και ενώστε τα δάχτυλα. Με Joy-Con, τα τοποθετεί εκεί όπου βρίσκονται πραγματικά τα χέρια σας. Οι εικόνες επεξεργάζονται σε αυτή τη συσκευή και δεν αποθηκεύονται ούτε αποστέλλονται ποτέ. + Παρακολούθηση χεριών ή χειριστηρίων Joy-Con με την κάμερα του τηλεφώνου; + Χωρίς συνδεδεμένο χειριστήριο, η κάμερα του τηλεφώνου παρακολουθεί τα γυμνά σας χέρια σε εικονική πραγματικότητα: τσιμπήστε τον αντίχειρα και τον δείκτη σας για να κάνετε κλικ, κλείστε το χέρι σας για να το πιάσετε και στρέψτε την παλάμη σας προς το μέρος σας και τσιμπήστε για να ανοίξετε το μενού. Με τα ζευγαρωμένα χειριστήρια Joy-Con, η κάμερα παρακολουθεί τη θέση τους, ενώ τα χειριστήρια Joy-Con παρέχουν περιστροφή και κουμπιά. Οι εικόνες υποβάλλονται σε επεξεργασία σε αυτήν τη συσκευή και δεν αποθηκεύονται ή αποστέλλονται ποτέ. Πίσω κάμερα Προτείνεται. Συνήθως πιο ευκρινής και ευρύτερη. Μπροστινή κάμερα @@ -2426,7 +2426,7 @@ Χρήση κάμερας Όχι τώρα Παρακολούθηση χεριών με κάμερα - Χωρίς συνδεδεμένο χειριστήριο, τα χέρια σας γίνονται τα χέρια VR: ενώστε τα δάχτυλα για κλικ, και με την παλάμη προς εσάς ενώστε τα για το μενού. Με Joy-Con, τα τοποθετεί εκεί όπου τα βλέπει η κάμερα. Οι εικόνες παραμένουν σε αυτή τη συσκευή. + Χρησιμοποιήστε την κάμερα του τηλεφώνου για χειρονομίες με γυμνά χέρια ή για να τοποθετήσετε τα συνδεδεμένα χειριστήρια Joy-Con σε εικονική πραγματικότητα. Τα χειριστήρια Joy-Con παρέχουν περιστροφή και εντολές κουμπιών. Παύει ενώ τα έξυπνα γυαλιά παρακολουθούν τα χέρια σας ή τα χειριστήρια Joy-Con. Οι εικόνες υποβάλλονται σε επεξεργασία μόνο σε αυτήν τη συσκευή. Κάμερα Πρόσβαση στην κάμερα Επιτρέψτε την πρόσβαση στην κάμερα για να ξεκινήσει η παρακολούθηση χεριών. @@ -2680,4 +2680,208 @@ Μετατροπή του %1$s για το Steam. Αφήστε το DroidDeck ανοιχτό. Η συσκευή δεν μπορεί να αποκωδικοποιήσει αυτό το βίντεο. Δεν ήταν δυνατή η εισαγωγή του βίντεο + Κάμερες Luma Ultra — Πειραματικό + Παρακολούθηση θέσης Joy-Con + Χρησιμοποιήστε τις κάμερες των έξυπνων γυαλιών για να τοποθετήσετε τα συνδεδεμένα χειριστήρια Joy-Con. Η περιστροφή και οι εντολές κουμπιών προέρχονται από τα χειριστήρια Joy-Con. Η θέση εκτιμάται όταν οι καρποί σας είναι κρυμμένοι. Αντικαθιστά τα χειριστήρια που λειτουργούν με γυμνά χέρια και διακόπτει την παρακολούθηση της κάμερας του τηλεφώνου. Στρέψτε τα χειριστήρια Joy-Con προς τα εμπρός κατά τη σύνδεση ή την επαναφορά του κέντρου παρακολούθησης. + Ενεργοποιήστε πρώτα την παρακολούθηση θέσης. Απαιτούνται χειριστήρια Joy-Con με δυνατότητα κίνησης σε Android 12 ή νεότερη έκδοση. Απενεργοποιημένα από προεπιλογή. + Έξυπνα γυαλιά + Οι ρυθμίσεις οθόνης και παρακολούθησης κεφαλιού είναι κοινές σε όλα τα μενού, τα παιχνίδια και τις συνεδρίες επιφάνειας εργασίας του DroidDeck. + Συνδέστε τα έξυπνα γυαλιά για να αλλάξετε τις ρυθμίσεις οθόνης και παρακολούθησης. Οι αποθηκευμένες ρυθμίσεις σας διατηρούνται όταν αποσυνδεθείτε. + VR (Εικονική πραγματικότητα) + Λειτουργία οθόνης + Έξοδος 2D + Έξοδος 3D + Εικόνα και εικονική οθόνη + Θέση και επίπεδο δαπέδου + Παρακολούθηση χεριών — Πειραματικό + Κατάσταση παρακολούθησης + Ανάλυση 2D + Ανάλυση 3D + Ανάλυση VR + Αυτόματη + Ίδιο με 2D / 3D + Ανάλυση εξόδου ανά μάτι. + Ενεργοποιήστε το Παιχνίδι σε έξυπνα γυαλιά για να επιλέξετε την εγγενή λειτουργία 30 Hz της οθόνης. + Εικονική οθόνη 3DoF + Αγκυρώστε τα επίπεδα παιχνίδια μπροστά σας, ώστε να μπορείτε να κοιτάτε τριγύρω. Ενεργοποιεί το Παιχνίδι σε έξυπνα γυαλιά χωρίς να μεταβείτε σε 3D. + Το πλάτος και η απόσταση ενημερώνουν αμέσως την εικονική οθόνη που παρακολουθείται για τα μενού, τα παιχνίδια και τις συνεδρίες επιφάνειας εργασίας του DroidDeck. + Η παρακολούθηση θέσης περιλαμβάνει την περιστροφή του κεφαλιού στο SteamVR. Για παρακολούθηση μόνο με περιστροφή, απενεργοποιήστε την παρακολούθηση θέσης. + Ελέγχει την κίνηση του κεφαλιού στην εικονική οθόνη. Η παρακολούθηση θέσης περιλαμβάνει την περιστροφή του κεφαλιού στο SteamVR. + Γρήγορες ενέργειες + Κοιτάξτε πού θέλετε την οθόνη και, στη συνέχεια, επαναφέρετε το κέντρο παρακολούθησης για να ορίσετε το ύψος και την κατεύθυνσή της. + Επανακεντράρισμα Joy-Con + Κάμερα τηλεφώνου — Πειραματικό + Παρακολούθηση χεριών ή χειριστηρίων Joy-Con + Εικονική οθόνη 6DoF + Παρακολούθηση θέσης — πειραματική + Φυσική κίνηση σε εικονική πραγματικότητα και γύρω από εικονικές οθόνες. Η επανεκκίνηση της παρακολούθησης διαρκεί λίγο χρόνο. + Τρέχον ύψος ματιών πάνω από το πάτωμα + Ορισμός επιπέδου δαπέδου από το τρέχον ύψος + Ορισμός επιπέδου δαπέδου + Ρύθμιση και διαγνωστικά στερεοσκοπικής κάμερας + Ελέγξτε τη βαθμονόμηση της κάμερας και την παρακολούθηση των χεριών πριν από το παιχνίδι. + Άνοιγμα ρύθμισης + Χειριστήρια που λειτουργούν με γυμνά χέρια + Χρησιμοποιήστε τις κάμερες έξυπνων γυαλιών για να στοχεύσετε με τα χέρια σας, πιέστε για να κάνετε κλικ και κλείστε το χέρι σας για να το πιάσετε σε εικονική πραγματικότητα. Τα sticks του Gamepad κινούνται και περιστρέφονται. Αντικαθιστά την παρακολούθηση θέσης Joy-Con. Ενδέχεται να καθυστερήσει ή να χάσει την παρακολούθηση κατά τη διάρκεια των παιχνιδιών. + Ενεργοποιήστε τα χειριστήρια που λειτουργούν με γυμνά χέρια κάτω από τις κάμερες Luma Ultra στην Παρακολούθηση. Εμφανίστε πρώτα τα ανοιχτά χέρια. + Κοινόχρηστη βαθμονόμηση Luma Ultra + Χρήση της κοινόχρηστης βάσης Luma Ultra. Βαθμονομήστε τα δικά σας έξυπνα γυαλιά για να επαληθεύσετε την ακρίβειά τους. + Επαληθεύτηκε η μετρούμενη βαθμονόμηση + Απαιτείται επικύρωση + Τα χειριστήρια που λειτουργούν με γυμνά χέρια γίνονται διαθέσιμα μετά την ολοκλήρωση του ελέγχου της μετρούμενης απόστασης. + Χάθηκε η παρακολούθηση + Κοιτάξτε αργά τριγύρω σε ένα καλά φωτισμένο δωμάτιο.\nΔιατηρήστε τις κάμερες παρακολούθησης καθαρές και στραμμένες προς τα έπιπλα ή άλλες ορατές λεπτομέρειες. + Ακόμα κολλημένοι; Στο τηλέφωνό σας: έξυπνα γυαλιά → Παρακολούθηση → Άνοιγμα ρύθμισης → Εμφάνιση διαγνωστικών → Επανεκκίνηση παρακολούθησης. + Τα έξυπνα γυαλιά αποσυνδέθηκαν + Ελέγξτε τη σύνδεση USB και επανασυνδέστε τα έξυπνα γυαλιά.\nΑποδεχτείτε το μήνυμα προτροπής πρόσβασης USB στο τηλέφωνό σας, εάν εμφανιστεί. + Μόλις συνδεθείτε, κοιτάξτε γύρω σας αργά σε ένα καλά φωτισμένο δωμάτιο για να επαναφέρετε την παρακολούθηση. + Απαιτείται επανακεντράρισμα + Η παρακολούθηση επέστρεψε σε νέα θέση.\nΚοιτάξτε προς τα εμπρός και, στη συνέχεια, πατήστε επαναφορά κέντρου παρακολούθησης στο τηλέφωνό σας. + Μπορείτε επίσης να βρείτε την επαναφορά του κέντρου παρακολούθησης στα έξυπνα γυαλιά → Παρακολούθηση → Άνοιγμα ρυθμίσεων. Η αποθηκευμένη βαθμονόμηση της κάμερας διατηρείται. + Μείνετε ακίνητοι για μια στιγμή + Η επαναφορά του κέντρου παρακολούθησης βρίσκεται σε εξέλιξη.\nΔιατηρήστε τα έξυπνα γυαλιά σταθερά ενώ η παρακολούθηση σταθεροποιείται. + Αυτή η οθόνη κλείνει αυτόματα όταν είναι έτοιμη η παρακολούθηση κεφαλής. + Σταθεροποιημένη σκόπευση με τα χέρια + Στόχευσε από τον ώμο μέσα από την παλάμη σου. Απενεργοποιήστε για περιστροφή ελεγχόμενη από τον καρπό. + Χωρική ρύθμιση + Αναμονή για παρακολούθηση… + Αριστερή και δεξιά κάμερες παρακολούθησης + Συγχρονισμός κάμερας + Έτοιμο + Αναμονή για την ευθυγράμμιση της κάμερας και της παρακολούθησης κεφαλιού. Διατηρήστε τα έξυπνα γυαλιά συνδεδεμένα. + 1. Προετοιμάστε τον στόχο βαθμονόμησης + Εκτύπωση σε πραγματικό μέγεθος + Κάθε πλευρά του τετραγώνου πρέπει να έχει μήκος 30 mm (1.181 in). Στερεώστε το φύλλο επίπεδα σε μια άκαμπτη επιφάνεια σε καλά φωτισμένο χώρο. + Εκτύπωση στόχου βαθμονόμησης + 2. Καταγράψτε διαφορετικές προβολές + Διατηρήστε σταθερό τον στόχο βαθμονόμησης + Μετακινήστε τα έξυπνα γυαλιά πιο κοντά, πιο μακριά και στο πλάι. Γυρίστε τα αριστερά/δεξιά, γωνίστε τα πάνω/κάτω και γείρετε τα προς τα πλάγια. Διατηρήστε τον στόχο βαθμονόμησης και στις δύο κάμερες και κάντε μια σύντομη παύση πριν από κάθε λήψη. + Έναρξη νέας βαθμονόμησης + Αναμονή για συγχρονισμό κάμερας. + Ξεκινήστε μια νέα βαθμονόμηση για τη συλλογή προβολών. + Διατηρήστε τον στόχο βαθμονόμησης ορατός και στις δύο προεπισκοπήσεις. Καταγράψτε τουλάχιστον 24 ευκρινείς προβολές από διαφορετικές γωνίες. + Λήψη… + Λήψη προβολής στόχου βαθμονόμησης + Υπολογισμός ευθυγράμμισης κάμερας + Υπολογισμός… + Υπολογισμός βαθμονόμησης + 3. Ελέγξτε την απόσταση + Μετρημένη απόσταση + Ξεκινήστε με 12 ίντσες ή 30 cm, ώστε οι εκτυπωμένοι δείκτες να είναι ευκολότερος να ανιχνευθούν. Επιλέξτε την ακριβή μέτρηση που θα χρησιμοποιήσετε. + Αριστερή κάμερα στο κέντρο στόχου βαθμονόμησης + Έλεγχος απόστασης… + Επικύρωση απόστασης + Διαγνωστικά + Εμφάνιση διαγνωστικών + Εργαλεία ανάκτησης χρονισμού και παρακολούθησης κάμερας. + Χρονισμός κάμερας + Είσοδος από παρακολούθηση χεριών + Αναμονή για τον χρονισμό της κάμερας. + Εικόνες κάμερας + Ανίχνευση χεριών με GPU + Η CPU είναι η προεπιλογή. Η GPU είναι πειραματική και μπορεί να προκαλέσει επανεκκίνηση του SteamVR. Αυτή η επιλογή επαναφέρεται κατά την επανεκκίνηση της παρακολούθησης. + Lite ανίχνευση μοντέλων χεριών + Χρησιμοποιήστε τον ανιχνευτή παλάμης Lite και τα βασικά σημεία Lite στα χέρια. Ελέγξτε την ακρίβεια στόχευσης, τσιμπήστε και πιάστε. Επαναφέρεται κατά την επανεκκίνηση της παρακολούθησης. + Αυτόματη συχνότητα εισόδου για παρακολούθηση των χεριών + Προσαρμόστε την είσοδο στην ταχύτητα επεξεργασίας. Επαναφέρεται κατά την επανεκκίνηση της παρακολούθησης. + Περιορίστε τη συχνότητα εισόδου για την παρακολούθηση των χεριών + Χρησιμοποιήστε τις μισές εικόνες της κάμερας. Απενεργοποιήστε για να συγκρίνετε τη μέγιστη συχνότητα. Επαναφέρεται κατά την επανεκκίνηση της παρακολούθησης. + Διαγνωστική σύλληψη + Αποθηκεύστε ένα ζεύγος στερεοφωνικής εικόνας τοπικά. Οι εικόνες αποθηκεύονται μόνο όταν ζητηθούν. + Αποθήκευση εικόνας κάμερας + Επανεκκινήστε την παρακολούθηση + Χρησιμοποιήστε το εάν η παρακολούθηση δεν επανέρχεται σε καλά φωτισμένη περιοχή. Η επανεκκίνηση απαιτεί νέα προέλευση παρακολούθησης. + Επανεκκίνηση + Επανεκκίνηση της παρακολούθησης; + Οι μη αποθηκευμένες προβολές βαθμονόμησης θα χαθούν. Κρατήστε τα έξυπνα γυαλιά ακίνητα αργότερα και επαναφέρετε το κέντρο παρακολούθησης όταν αποκατασταθεί η παρακολούθηση. + %1$d / 24 προβολές καταγράφηκαν + Λήψη σε παύση: %1$s + Μέτρο %1$s. Εμφάνιση του πλήρους στόχου βαθμονόμησης και στις δύο προεπισκοπήσεις και, στη συνέχεια, κρατήστε ακίνητο. + %1$.1f Hz • ηλικία εικόνας %2$.1f ms • επεξεργασία %3$.1f ms + Όριο εισόδου %1$.1f Hz • %2$.0f%% εικόνων κάμερας. Η παρακολούθηση της κεφαλής συνεχίζεται στη μέγιστη συχνότητά της. + %1$d υποβλήθηκε σε επεξεργασία • %2$d απορρίφθηκε • %3$d παραβλέφθηκε από το όριο εισαγωγής + DroidDeck ChArUco 30 mm + Βαθμονόμηση DroidDeck - Luma Ultra + Εκτύπωση σε 100% / Πραγματικό μέγεθος. Κάθε τετράγωνο: 30 mm (1.181 in). + Διατηρήστε το στόχο βαθμονόμησης επίπεδο και ακίνητο. μετακινήστε τα έξυπνα γυαλιά ανάμεσα στις λήψεις. + Έλεγχος κλίμακας: 100 mm (3.937 ίντσες) μεταξύ των κροτώνων + 12 ίντσες (30,48 cm) + 30 cm (11,81 ίντσες) + 20 ίντσες (50,8 cm) + 50 cm (19,69 ίντσες) + Απενεργοποιημένο + Αναμονή για σταθερή παρακολούθηση + Αποσυνδέθηκε + Οι ελεγκτές που λειτουργούν με γυμνά χέρια είναι απενεργοποιημένοι + Η παρακολούθηση θέσης είναι απενεργοποιημένη ή τα έξυπνα γυαλιά έχουν αποσυνδεθεί + Ζητήθηκε επαναφορά του κέντρου παρακολούθησης — μείνετε ακίνητοι ενώ η παρακολούθηση σταθεροποιείται + Παρακολούθηση χαμένη — αντιμετωπίστε μια καλά φωτισμένη περιοχή με ορατές λεπτομέρειες + Άλλαξε η προέλευση παρακολούθησης — πατήστε επαναφορά του κέντρου παρακολούθησης και, στη συνέχεια, κρατήστε ακίνητοι + 6DoF ενεργό + Συνδέστε το Luma Ultra και ενεργοποιήστε την παρακολούθηση θέσης. + Η βαθμονόμηση επαληθεύτηκε για αυτήν τη σύνδεση. + Η βαθμονόμηση επαληθεύτηκε και αποθηκεύτηκε. + Αναμονή για στερεοφωνικές κάμερες + Αναμονή για παρακολούθηση των χεριών + Διατηρήστε σταθερό τον στόχο βαθμονόμησης 5 × 7. Καταγράψτε 24+ προβολές ενώ μετακινείτε και περιστρέφετε τα έξυπνα γυαλιά. + Αναμονή για την επόμενη εικόνα κάμερας. Κρατήστε τα έξυπνα γυαλιά ακίνητα. + Έλεγχος της επόμενης εικόνας κάμερας. Διατηρήστε ορατό τον πλήρη στόχο βαθμονόμησης και κρατήστε ακίνητο. + Ξεκινήστε πρώτα τη βαθμονόμηση + Δεν έφτασε καμία νέα εικόνα κάμερας. Ελέγξτε τη σύνδεση των έξυπνων γυαλιών και τις προεπισκοπήσεις της κάμερας και, στη συνέχεια, δοκιμάστε ξανά. + Επαναφορά ρολογιού κάμερας + Το σύστημα συντεταγμένων παρακολούθησης άλλαξε. Οι προβολές σας αποθηκεύονται για επανυπολογισμό. Επαναφέρετε το κέντρο παρακολούθησης και, στη συνέχεια, ξεκινήστε ένα νέο σύνολο για να καταγράψετε περισσότερες προβολές. + φορτώθηκε η βαθμονόμηση της συσκευής + Φορτώθηκε η βαθμονόμηση βάσης Luma Ultra + απαιτείται βαθμονόμηση + Πατήστε Πρώτα Έναρξη νέας βαθμονόμησης. + Η επαναφορά του κέντρου παρακολούθησης αναμένει σταθερή παρακολούθηση. Κρατήστε ακίνητοι για μια στιγμή. + Η παρακολούθηση άλλαξε. Πατήστε επαναφορά του κέντρου παρακολούθησης μία φορά και, στη συνέχεια, κρατήστε ακίνητοι πριν από τη λήψη. + Η λήψη απορρίφθηκε: η παρακολούθηση κεφαλής δεν ήταν συγχρονισμένη ή άλλαξε κατά τη λήψη. Μείνετε ακίνητοι και δοκιμάστε ξανά. + Υπολογίστε την ευθυγράμμιση της κάμερας πριν ελέγξετε την απόσταση. + Η επεξεργασία της κάμερας απέτυχε + Η παρακολούθηση κεφαλιού άλλαξε κατά την ανίχνευση των χεριών + Αναμονή για συγχρονισμό κάμερας και κεφαλής + Δεν εντοπίστηκαν καρποί. Κρατήστε τις λαβές του ελεγκτή Joy-Con μπροστά από τα έξυπνα γυαλιά + Δεν εντοπίστηκαν χέρια. Δείξτε ανοιχτές παλάμες μπροστά από τα έξυπνα γυαλιά + Καρποί ορατοί μόνο σε μία κάμερα. κρατήστε τις λαβές του ελεγκτή σας στην κοινόχρηστη προβολή + Τα χέρια ορατά μόνο σε μία κάμερα. κρατήστε και τις δύο παλάμες στην κοινή θέα + Και οι δύο κάμερες βλέπουν τα χέρια, αλλά η αντιστοίχιση αριστερά/δεξιά είναι διφορούμενη + Εντοπίστηκαν χέρια, αλλά το στερεοφωνικό βάθος είναι ασυνεπές + Η θέση του καρπού απορρίπτεται με στερεοφωνικό έλεγχο ή έλεγχο κίνησης + Εντοπίστηκαν στερεοφωνικά σημεία, αλλά η γεωμετρία της παλάμης είναι ασυνεπής + Ολοκληρώστε τη βαθμονόμηση και τον έλεγχο απόστασης για να ενεργοποιήσετε τα χέρια + Αναμονή για σταθερή παρακολούθηση κεφαλής. Επαναφέρετε το κέντρο παρακολούθησης εάν ζητηθεί + Η παρατήρηση με κάμερα είναι πολύ παλιά. περιμένοντας ένα φρέσκο ζευγάρι + Προσαρμογή %1$.2f px. Μετρήστε την επιλεγμένη απόσταση από την αριστερή κάμερα μέχρι το κέντρο στόχου βαθμονόμησης και, στη συνέχεια, επικυρώστε. + Το OpenCV δεν είναι διαθέσιμο: %1$s + Αποκαταστάθηκαν οι αποθηκευμένες προβολές %1$d. Υπολογίστε τη βαθμονόμηση για να προσπαθήσετε ξανά ή ξεκινήστε ένα νέο σύνολο για να καταγράψετε περισσότερα. + Λήψη %1$d / 24 προβολές. Διατηρήστε σταθερό τον στόχο βαθμονόμησης. μετακινήστε τα έξυπνα γυαλιά για την επόμενη προβολή. + Η λήψη απορρίφθηκε: %1$d / 12 απαιτούμενες γωνίες ορατές και στις δύο κάμερες. Εμφάνιση μεγαλύτερου μέρους του στόχου βαθμονόμησης, κρατήστε ακίνητο και μετά δοκιμάστε ξανά. + Ο έλεγχος απόστασης δεν μπόρεσε να ολοκληρωθεί: %1$s. Προσπαθήστε ξανά. + Μη διαθέσιμος εντοπισμός χεριών: %1$s. Αλλάξτε την CPU/GPU ή αλλάξτε τους ελεγκτές που λειτουργούν με γυμνά χέρια για να προσπαθήσετε ξανά. + Η ανίχνευση χεριών υπερέβη τα %1$d ms. η παρατήρηση απορρίφθηκε + %1$d / 2 θέσεις καρπού Joy-Con μετρημένες με στερεοφωνικό + Παρακολουθούμενες παλάμες: %1$d / 2· ετοιμότητα τσιμπήματος: %2$d· ετοιμότητα λαβής: %3$d + Αποθηκεύτηκε η διαγνωστική λήψη στο %1$s + Η παρακολούθηση των χεριών σταμάτησε: %1$s + Στερεοφωνικό %1$d×%2$d; %3$s + Η παρακολούθηση κεφαλής και ο στόχος βαθμονόμησης διαφωνούν κατά %1$s (όριο 5 cm / 2 in). Διατηρήστε σταθερό τον στόχο βαθμονόμησης και περιμένετε για σταθερή παρακολούθηση πριν ξεκινήσετε ένα νέο σετ. Γυρίστε και γείρετε τα έξυπνα γυαλιά απαλά. παύση πριν από κάθε λήψη. + Καταγράψτε τουλάχιστον 24 διαφορετικές όψεις του σταθερού στόχου βαθμονόμησης. + Γυρίστε τα έξυπνα γυαλιά αριστερά και δεξιά και γείρετε τα πάνω-κάτω. Η κίνηση χωρίς περιστροφή δεν μπορεί να βαθμονομήσει την ευθυγράμμιση της κάμερας. + Απίστευτη γραμμή βάσης κάμερας + Μετακινήστε το κεφάλι σας σε πιο ποικίλους προσανατολισμούς. + Μη έγκυρη περιστροφή κάμερας με κεφαλή + Η ευθυγράμμιση κάμερας με κεφαλή είναι ασυνεπής. + Η βαθμονόμηση δεν μπόρεσε να ολοκληρωθεί. %1$s Οι προβολές που έχετε καταγράψει αποθηκεύονται. + Το παρατεταμένο σφάλμα επαναπροβολής %1$.2f px υπερβαίνει τα 2 px. Επαναβαθμονόμηση. + Εντοπίστηκαν %1$d / 24 γωνίες σκακιέρας και στις δύο κάμερες. Κρατήστε ολόκληρο τον στόχο βαθμονόμησης ορατό και παραμείνετε ακίνητοι. Εάν είναι ήδη ορατός, επιλέξτε 12 in ή 30 cm και μετρήστε αυτήν τη μικρότερη απόσταση πριν προσπαθήσετε ξανά. + Ο στόχος βαθμονόμησης είναι ορατός, αλλά το βάθος του δεν μπορούσε να μετρηθεί αξιόπιστα. Κρατήστε τα έξυπνα γυαλιά ακίνητα και διατηρήστε το στόχο βαθμονόμησης επίπεδο και καλά φωτισμένο και, στη συνέχεια, δοκιμάστε ξανά. + Η μέτρηση της κάμερας δεν ήταν έγκυρη. Μείνετε ακίνητοι και δοκιμάστε ξανά. + Ο έλεγχος εξ αποστάσεως πέρασε. + Ελέγξτε ξανά την απόσταση από την αριστερή κάμερα μέχρι το κέντρο στόχου βαθμονόμησης και, στη συνέχεια, δοκιμάστε ξανά. + Κάμερες μέτρησης %1$s. επιλεγμένη απόσταση %2$s. %3$s + Περιμένετε και για τις δύο προεπισκοπήσεις κάμερας πριν ξεκινήσετε τη βαθμονόμηση. + Οι αποθηκευμένες προβολές μπορούν να υπολογιστούν εκ νέου. Ξεκινήστε μια νέα βαθμονόμηση για αποτύπωση στο τρέχον σύστημα συντεταγμένων παρακολούθησης. + Αναντιστοιχία αθροίσματος ελέγχου μοντέλου χεριού + Δεν ήταν δυνατή η φόρτωση του OpenCV diff --git a/app/src/main/res/values-es/strings.xml b/app/src/main/res/values-es/strings.xml index 94710b72ad..f576e95823 100644 --- a/app/src/main/res/values-es/strings.xml +++ b/app/src/main/res/values-es/strings.xml @@ -2374,14 +2374,14 @@ Pantalla Frecuencia de actualización 3D (lado a lado) - Cada ojo recibe su propia mitad de una imagen de 3840×1080. Si la imagen se pierde, mantén pulsado el botón 2D/3D de las gafas. + Cambia las gafas inteligentes a 3D lado a lado. El seguimiento de la cabeza se controla por separado. No se ha confirmado la señal 3D. Inténtalo de nuevo cuando vuelva la imagen 2D. Sin imagen: las gafas están en un modo que este teléfono no puede enviar. Mantén pulsado su botón 2D/3D o desconéctalas y vuelve a conectarlas. Frecuencia en 3D 3D para juegos de RV Cambia a 3D mientras SteamVR está en marcha, y vuelve después. - Imagen 3D - Automático: SteamVR llena la vista; los demás juegos flotan como una pantalla en 3D y se ven planos en 2D. + Imagen + Muestra automáticamente contenido plano en ambos ojos y detecta SteamVR. Seleccione Juego lado a lado para contenido SBS. Automático Pantalla virtual Juego lado a lado @@ -2391,20 +2391,20 @@ Estos ajustes se aplican mientras Juego en las gafas está activado y el juego se muestra allí. Automático mantiene este juego 2D a pantalla completa. Usa una pantalla virtual para ajustar su ancho, distancia y seguimiento de cabeza. Usar pantalla virtual - SteamVR llena la vista. Ajusta su campo de visión abajo; el ancho y la distancia solo se aplican a una pantalla virtual. + SteamVR llena la vista. Ajuste su campo de visión en RV; el ancho y la distancia solo se aplican a una pantalla virtual. Los juegos lado a lado llenan cada ojo. El ancho y la distancia solo se aplican a una pantalla virtual. Automático mantiene este juego 2D fijo en la vista. Elige Pantalla virtual en la sección Pantalla para usar el seguimiento de cabeza. El seguimiento de cabeza se aplica a una pantalla virtual o a un juego de SteamVR en marcha. - Gafas + Dispositivo Brillo Volumen Bloqueo solar Oscurece las lentes frontales. - Seguimiento de cabeza + Seguimiento Seguimiento de cabeza Los sensores de las gafas giran la pantalla virtual y SteamVR con tu cabeza. Recentrar la vista - Recentrar + Volver a centrar la pantalla Campo de visión de SteamVR Más bajo acerca SteamVR y llena las gafas; más alto muestra más a tu alrededor. Jugando en %1$s @@ -2425,8 +2425,8 @@ ¿Quitar la calibración guardada y restaurar los valores predeterminados del modelo? Recentra después de volver a ponerte las gafas. Restablecer Seguimiento de manos - ¿Seguir tus manos con la cámara? - La cámara puede ver tus manos. Sin ningún mando conectado, tus manos desnudas pasan a ser las manos de RV: junta el pulgar y el índice para hacer clic, cierra la mano para agarrar y, para abrir el menú, gira la palma hacia ti y junta los dedos. Con Joy-Con, los coloca donde están de verdad tus manos. Las imágenes se procesan en este dispositivo y nunca se guardan ni se envían. + ¿Rastrear las manos o los mandos Joy-Con con la cámara del teléfono? + Sin ningún mando conectado, la cámara del teléfono rastrea tus manos en realidad virtual: pellizca con el pulgar y el índice para hacer clic, cierra la mano para agarrar y gira la palma hacia ti y pellizca para abrir el menú. Con los mandos Joy-Con emparejados, la cámara rastrea su posición mientras los mandos Joy-Con proporcionan la rotación y las entradas de los botones. Las imágenes se procesan en este dispositivo y nunca se guardan ni se envían. Cámara trasera Recomendada. Suele ser más nítida y amplia. Cámara frontal @@ -2434,7 +2434,7 @@ Usar cámara Ahora no Seguimiento de manos por cámara - Sin ningún mando conectado, tus manos pasan a ser las manos de RV: junta los dedos para hacer clic y, con la palma hacia ti, júntalos para abrir el menú. Con Joy-Con, los coloca donde la cámara los ve. Las imágenes se quedan en este dispositivo. + Usa la cámara del teléfono para gestos con las manos desnudas o para posicionar los mandos Joy-Con emparejados en realidad virtual. Los mandos Joy-Con proporcionan la rotación y las pulsaciones de los botones. Se pausa mientras las gafas inteligentes rastrean tus manos o los mandos Joy-Con. Las imágenes se procesan solo en este dispositivo. Cámara Acceso a la cámara Permite el acceso a la cámara para que el seguimiento de manos pueda empezar. @@ -2705,4 +2705,208 @@ Convirtiendo %1$s para Steam. Mantén DroidDeck abierto. Este dispositivo no puede decodificar ese vídeo. No se pudo importar ese vídeo + Cámaras Luma Ultra — Experimental + Seguimiento de posición de los Joy-Con + Usa las cámaras de las gafas inteligentes para posicionar tus mandos Joy-Con emparejados. La rotación y las pulsaciones de los botones provienen de los mandos Joy-Con. La posición se estima cuando tus muñecas están ocultas. Reemplaza los mandos operados con las manos desnudas y pausa el seguimiento de la cámara del teléfono. Apunta los mandos Joy-Con hacia adelante al conectar o restablecer el centro de seguimiento. + Activa primero el seguimiento de posición. Requiere mandos Joy-Con compatibles con movimiento en Android 12 o posterior. Desactivado por defecto. + Gafas inteligentes + La configuración de pantalla y seguimiento de cabeza se comparte entre los menús de DroidDeck, los juegos y las sesiones de escritorio. + Conecta las gafas inteligentes para cambiar su configuración de pantalla y seguimiento. Tu configuración guardada se conserva al desconectarlas. + RV + Modo de visualización + Salida 2D + Salida 3D + Imagen y pantalla virtual + Posición y nivel del suelo + Seguimiento de manos — Experimental + Estado del seguimiento + Resolución 2D + Resolución 3D + Resolución RV + Automático + Igual que 2D/3D + Resolución de salida por ojo. + Habilita el juego en gafas inteligentes para seleccionar el modo nativo de 30 Hz de la pantalla. + Pantalla virtual 3DoF + Ancla los juegos planos frente a ti para que puedas mirar a tu alrededor. Habilita el juego en gafas inteligentes sin cambiar a 3D. + El ancho y la distancia actualizan la pantalla virtual rastreada para los menús, juegos y sesiones de escritorio de DroidDeck de forma inmediata. + El seguimiento posicional incluye la rotación de la cabeza en SteamVR. Para el seguimiento solo de rotación, desactive el seguimiento posicional. + Controla el movimiento de la cabeza en la pantalla virtual. El seguimiento posicional incluye la rotación de la cabeza en SteamVR. + Acciones rápidas + Mira hacia donde quieras que esté la pantalla y luego restablece el centro de seguimiento para ajustar su altura y dirección. + Volver a centrar los Joy-Con + Cámara del teléfono — Experimental + Rastrear manos o mandos Joy-Con + Pantalla virtual 6DoF + Seguimiento posicional — experimental + Movimiento físico en RV y alrededor de pantallas virtuales. Reiniciar el seguimiento tarda un momento. + Altura actual de los ojos sobre el suelo + Establecer el nivel del suelo desde la altura actual + Establecer el nivel del suelo + Configuración y diagnóstico de la cámara estéreo + Comprobar la calibración de la cámara y el seguimiento de las manos antes de jugar. + Abrir configuración + Mandos operados con las manos desnudas + Usar las cámaras de las gafas inteligentes para apuntar con las manos, pellizcar para hacer clic y cerrar la mano para agarrar en RV. Los joysticks del mando se mueven y giran. Sustituye el seguimiento de posición de los Joy-Con. Puede haber retrasos o pérdida de seguimiento durante los juegos. + Habilitar el uso de mandos operados con las manos desnudas bajo las cámaras Luma Ultra en Seguimiento. Mostrar primero las manos abiertas. + Calibración compartida de Luma Ultra + Usar la base compartida de Luma Ultra. Calibra tus gafas inteligentes para verificar su precisión. + Calibración medida verificada + Validación requerida + Los controladores operados con las manos desnudas estarán disponibles después de que la verificación de distancia medida sea exitosa. + Seguimiento perdido + Mira a tu alrededor lentamente en una habitación bien iluminada.\nMantén las cámaras de seguimiento despejadas y enfoca los muebles u otros detalles visibles. + ¿Sigues estancado? En su teléfono: gafas inteligentes → Seguimiento → Abrir configuración → Mostrar diagnóstico → Reiniciar seguimiento. + Gafas inteligentes desconectadas + Verifique la conexión USB y vuelva a conectar las gafas inteligentes.\nAcepte el mensaje de acceso USB en su teléfono si aparece. + Una vez conectado, mire lentamente a su alrededor en una habitación bien iluminada para restablecer el seguimiento. + Es necesario volver a centrar + El seguimiento ha vuelto a una nueva posición.\nMira hacia adelante y luego toca \"Restablecer centro de seguimiento\" en tu teléfono. + También puedes encontrar la opción para restablecer el centro de seguimiento en las gafas inteligentes → Seguimiento → Abrir configuración. Se conserva la calibración de la cámara guardada. + Quédate quieto por un momento + El restablecimiento del centro de seguimiento está en curso.\nMantén las gafas inteligentes estables mientras se estabiliza el seguimiento. + Esta pantalla se cierra automáticamente cuando el seguimiento de la cabeza está listo. + Apuntar estabilizado con las manos + Apunta desde tu hombro a través de tu palma. Apague para rotación controlada por la muñeca. + Configuración espacial + Esperando seguimiento… + Cámaras de seguimiento izquierda y derecha + Sincronización de cámaras + Listo + Esperando que la cámara y el seguimiento de la cabeza se alineen. Mantenga las gafas inteligentes conectadas. + 1. Prepare el objetivo de calibración + Imprimir en tamaño real + Cada cuadrado debe medir 30 mm (1.181 in). Monte la hoja plana sobre una superficie rígida en un área bien iluminada. + Imprimir patrón de calibración + 2. Captura diferentes vistas + Mantener estacionario el objetivo de calibración + Acerque, aleje y lateralmente las gafas inteligentes. Gírelos hacia la izquierda/derecha, inclínelos hacia arriba/abajo e inclínelos hacia los lados. Mantenga el objetivo de calibración en ambas cámaras y haga una pausa breve antes de cada captura. + Iniciar nueva calibración + Esperando sincronización de cámaras. + Inicie una nueva calibración para recopilar vistas. + Mantenga el objetivo de calibración visible en ambas vistas previas. Capture al menos 24 vistas nítidas desde diferentes ángulos. + Capturando… + Capturar vista del objetivo de calibración + Calcular la alineación de la cámara + Calculando… + Calcular calibración + 3. Verifique la distancia + Distancia medida + Comience con 12 pulgadas o 30 cm para que los marcadores impresos sean más fáciles de detectar. Elige la medida exacta que utilizarás. + Cámara izquierda al centro del objetivo de calibración + Comprobando la distancia... + Validar distancia + Diagnóstico + Mostrar diagnóstico + Herramientas de recuperación de seguimiento y sincronización de cámaras. + Sincronización de la cámara + Entrada del seguimiento de manos + Esperando la sincronización de la cámara. + Imágenes de la cámara + Detección de manos por GPU + CPU es el valor predeterminado. La GPU es experimental y puede hacer que SteamVR se reinicie. Esta opción se restablece cuando se reinicia el seguimiento. + Detección Lite de modelos de manos. + Utilice el detector de palma Lite y los puntos clave Lite en las manos. Compruebe la precisión de apuntar, pellizcar y agarrar. Se reinicia cuando se reinicia el seguimiento. + Frecuencia de entrada automática para seguimiento de manos + Ajusta la entrada a la velocidad de procesamiento. Se reinicia cuando se reinicia el seguimiento. + Limitar la frecuencia de entrada para el seguimiento de manos + Utilice la mitad de las imágenes de la cámara. Apague para comparar la frecuencia máxima. Se reinicia cuando se reinicia el seguimiento. + Captura de diagnóstico + Guarde un par de imágenes estéreo localmente. Las imágenes se guardan sólo cuando se solicitan. + Guardar imagen de la cámara + Reiniciar seguimiento + Úselo si el seguimiento no se recupera en un área bien iluminada. Un reinicio requiere un nuevo origen de seguimiento. + Reiniciar + ¿Reiniciar el seguimiento? + Se perderán las vistas de calibración no guardadas. Mantén las gafas inteligentes quietas y restablece el centro de seguimiento cuando se restablezca el seguimiento. + %1$d / 24 vistas capturadas + Captura en pausa: %1$s + Medida %1$s. Muestre el objetivo de calibración completo en ambas vistas previas y luego quédese quieto. + %1$.1f Hz • antigüedad de la imagen %2$.1f ms • procesamiento %3$.1f ms + Límite de entrada %1$.1f Hz • %2$.0f%% de imágenes de la cámara. El seguimiento de la cabeza continúa con su frecuencia máxima. + %1$d procesado • %2$d descartado • %3$d omitido por límite de entrada + DroidDeck ChArUco 30 mm + DroidDeck - Calibración de Luma Ultra + Imprimir a 100% / Tamaño real. Cada cuadrado: 30 mm (1,181 pulgadas). + Mantenga el objetivo de calibración plano y estacionario; mueve las gafas inteligentes entre capturas. + Verificación de escala: 100 mm (3,937 in) entre marcas + 12 pulgadas (30,48 cm) + 30 cm (11,81 pulgadas) + 20 pulgadas (50,8 cm) + 50 cm (19,69 pulgadas) + Deshabilitado + Esperando seguimiento estable + Desconectado + Los controladores operados con las manos desnudas están apagados + El seguimiento posicional está desactivado o las gafas inteligentes están desconectadas + Se ha solicitado el restablecimiento del centro de seguimiento; mantén las gafas quietas mientras se estabiliza el seguimiento. + Seguimiento perdido: frente a un área bien iluminada con detalles visibles + El origen del seguimiento ha cambiado; pulsa el botón para restablecer el centro de seguimiento y mantén las gafas quietas. + 6DoF activo + Conecte Luma Ultra y habilite el seguimiento posicional. + Calibración verificada para esta conexión. + Calibración verificada y guardada. + Esperando cámaras estéreo + Esperando seguimiento de manos + Mantenga estacionario el objetivo de calibración 5 × 7. Capture más de 24 vistas mientras mueve y gira las gafas inteligentes. + Esperando la siguiente imagen de la cámara. Mantenga quietas las gafas inteligentes. + Comprobación de la siguiente imagen de la cámara. Mantenga visible el objetivo de calibración completo y manténgalo quieto. + Iniciar la calibración primero + No llegó ninguna imagen nueva de la cámara. Verifique la conexión de las gafas inteligentes y las vistas previas de la cámara, luego vuelva a intentarlo. + Reinicio del reloj de la cámara + El sistema de coordenadas de seguimiento ha cambiado. Tus vistas se guardan para su recálculo. Restablece el centro de seguimiento y, a continuación, inicia una nueva configuración para capturar más vistas. + calibración del dispositivo cargada + Calibración de base Luma Ultra cargada + calibración requerida + Toque Iniciar nueva calibración primero. + El restablecimiento del centro de seguimiento está esperando un seguimiento estable. Mantén las gafas quietas un momento. + El seguimiento ha cambiado. Pulsa el botón para restablecer el centro de seguimiento una vez y, a continuación, mantén las gafas quietas antes de capturar. + Captura rechazada: el seguimiento de la cabeza no se sincronizó o cambió durante la captura. Quédate quieto y vuelve a intentarlo. + Calcule la alineación de la cámara antes de verificar la distancia. + el procesamiento de la cámara falló + El seguimiento de la cabeza cambió durante la detección de manos + Esperando la sincronización de la cámara y el cabezal + No se detectaron muñecas. Mantenga las manijas del controlador Joy-Con frente a las gafas inteligentes + No se detectaron manos. Muestre las palmas abiertas frente a las gafas inteligentes. + Muñecas visibles en una sola cámara; mantenga los identificadores de su controlador en la vista compartida + Manos visibles en una sola cámara; mantenga ambas palmas en la vista compartida + Ambas cámaras ven manos, pero la coincidencia izquierda/derecha es ambigua + Se detectaron manos, pero la profundidad estéreo no es consistente + Posición de la muñeca rechazada por controles estéreo o de movimiento + Se detectaron puntos estéreo, pero la geometría de la palma es inconsistente + Calibración completa y verificación de distancia para permitir que las manos + Esperando un seguimiento de cabeza estable; restablece el centro de seguimiento si se solicita. + La observación con cámara es demasiado antigua; esperando un par nuevo + Ajustar %1$.2f px. Mida la distancia seleccionada desde la cámara izquierda hasta el centro del objetivo de calibración y luego valide. + OpenCV no disponible: %1$s + %1$d vistas guardadas restauradas. Calcule la calibración para volver a intentarlo o comience un nuevo conjunto para capturar más. + Capturado %1$d / 24 vistas. Mantenga fijo el objetivo de calibración; Mueva las gafas inteligentes para la siguiente vista. + Captura rechazada: %1$d / 12 esquinas requeridas visibles en ambas cámaras. Muestre más del objetivo de calibración, quédese quieto y vuelva a intentarlo. + La verificación de distancia no pudo finalizar: %1$s. Intentar otra vez. + Detección de manos no disponible: %1$s. Cambie la CPU/GPU o cambie los controladores operados con las manos desnudas para volver a intentarlo. + La detección de manos superó los %1$d ms; observación descartada + %1$d / 2 posiciones de muñeca Joy-Con medidas por estéreo + Palmas seguidas: %1$d / 2; gesto de pinza listo: %2$d; agarre listo: %3$d + Captura de diagnóstico guardada en %1$s + Seguimiento de manos detenido: %1$s + Estéreo %1$d×%2$d; %3$s + El seguimiento de la cabeza y el objetivo de calibración difieren en %1$s (límite de 5 cm/2 pulgadas). Mantenga fijo el objetivo de calibración y espere un seguimiento constante antes de comenzar una nueva serie. Gire e incline suavemente las gafas inteligentes; pausa antes de cada captura. + Capture al menos 24 vistas variadas del objetivo de calibración estacionario. + Gire las gafas inteligentes hacia la izquierda y hacia la derecha, e inclínelas hacia arriba y hacia abajo; el movimiento sin rotación no puede calibrar la alineación de la cámara. + Línea de base de cámara inverosímil + Mueve la cabeza en orientaciones más variadas. + Rotación de cámara a cabezal no válida + La alineación entre la cámara y el cabezal es inconsistente. + La calibración no pudo finalizar. %1$s Tus vistas capturadas se guardan. + El error de reproyección retenida %1$.2f px supera los 2 px. Recalibrar. + %1$d / 24 esquinas de tablero de ajedrez detectadas en ambas cámaras. Mantenga visible el objetivo de calibración completo y manténgalo quieto. Si ya es visible, seleccione 12 pulgadas o 30 cm y mida esa distancia más cercana antes de volver a intentarlo. + El objetivo de calibración es visible, pero su profundidad no se pudo medir de manera confiable. Mantenga las gafas inteligentes quietas y mantenga el objetivo de calibración plano y bien iluminado, luego vuelva a intentarlo. + La ​​medición de la cámara no fue válida. Quédate quieto y vuelve a intentarlo. + Se pasó la verificación de distancia. + Vuelva a verificar la distancia desde la cámara izquierda al centro del objetivo de calibración y luego vuelva a intentarlo. + Las cámaras midieron %1$s; distancia seleccionada %2$s. %3$s + Espere las vistas previas de ambas cámaras antes de comenzar la calibración. + Las vistas guardadas se pueden recalcular. Inicie una nueva calibración para capturar en el sistema de coordenadas de seguimiento actual. + La suma de comprobación del modelo de mano no coincide + OpenCV no se pudo cargar diff --git a/app/src/main/res/values-fi/strings.xml b/app/src/main/res/values-fi/strings.xml index e3e9276573..7c12aaa946 100644 --- a/app/src/main/res/values-fi/strings.xml +++ b/app/src/main/res/values-fi/strings.xml @@ -2366,14 +2366,14 @@ Näyttö Virkistystaajuus 3D (rinnakkain) - Kumpikin silmä saa oman puoliskonsa 3840×1080-kuvasta. Jos kuva katoaa, pidä lasien 2D/3D-painiketta pohjassa. + Vaihda älylasit vierekkäiseen 3D-tilaan. Pään seurantaa ohjataan erikseen. 3D-signaalia ei voitu vahvistaa. Yritä uudelleen, kun 2D-kuva palautuu. Ei kuvaa: lasit ovat tilassa, jota tämä puhelin ei pysty lähettämään. Pidä niiden 2D/3D-painiketta pohjassa tai irrota ja kytke ne uudelleen. 3D-virkistystaajuus 3D VR-peleille Vaihtaa 3D:hen SteamVR:n ollessa käynnissä ja takaisin sen jälkeen. - 3D-kuva - Automaattinen: SteamVR täyttää näkymän; muut pelit leijuvat näyttönä 3D:ssä ja pysyvät litteinä 2D:ssä. + Kuva + Automaattinen toiminto näyttää tasaisen sisällön molemmissa silmissä ja tunnistaa SteamVR:n. Valitse SBS-sisällölle Vierekkäin-peli. Automaattinen Virtuaalinen näyttö Pelin rinnakkais-3D @@ -2383,20 +2383,20 @@ Nämä asetukset ovat käytössä, kun Peli laseissa on päällä ja peli näkyy niissä. Automaattinen pitää tämän 2D-pelin koko näytön tilassa. Käytä virtuaalista näyttöä, jos haluat säätää sen leveyttä, etäisyyttä ja pään seurantaa. Käytä virtuaalista näyttöä - SteamVR täyttää näkymän. Säädä sen näkökenttää alla; leveys ja etäisyys koskevat vain virtuaalista näyttöä. + SteamVR täyttää näkymän. Säädä sen näkökenttää VR:ssä; leveys ja etäisyys koskevat vain virtuaalinäyttöä. Rinnakkais-3D-pelit täyttävät kummankin silmän näkymän. Leveys ja etäisyys koskevat vain virtuaalista näyttöä. Automaattinen pitää tämän 2D-pelin paikallaan näkymässä. Valitse Näyttö-kohdasta Virtuaalinen näyttö, jos haluat käyttää pään seurantaa. Pään seuranta koskee virtuaalista näyttöä tai käynnissä olevaa SteamVR-peliä. - Lasit + Laite Kirkkaus Äänenvoimakkuus Tummennus Tummentaa etulinssit. - Pään seuranta + Seuranta Pään seuranta Lasien omat anturit kääntävät virtuaalista näyttöä ja SteamVR:ää pääsi mukana. Keskitä näkymä - Keskitä + Keskitä näyttö uudelleen SteamVR:n näkökenttä Pienempi tuo SteamVR:n lähemmäs ja täyttää lasit; suurempi näyttää enemmän ympäriltäsi. Pelataan laitteella %1$s @@ -2417,8 +2417,8 @@ Poistetaanko tallennettu kalibrointi ja palautetaanko mallin oletukset? Keskitä näkymä, kun olet laittanut lasit takaisin päähän. Nollaa Käden seuranta - Seurataanko käsiäsi kameralla? - Kamera näkee kätesi. Kun ohjainta ei ole yhdistetty, paljaista käsistäsi tulee VR-kädet: napsauta nipistämällä peukalo ja etusormi yhteen, tartu puristamalla käsi nyrkkiin ja avaa valikko kääntämällä kämmen itseäsi kohti ja nipistämällä. Joy-Conien kanssa kamera sijoittaa ne sinne, missä kätesi oikeasti ovat. Kuvat käsitellään tällä laitteella eikä niitä koskaan tallenneta tai lähetetä. + Seurataanko käsiä vai Joy-Con-ohjaimia puhelimen kameralla? + Kun ohjainta ei ole kytketty, puhelimen kamera seuraa paljaita käsiäsi VR:ssä: purista peukaloa ja etusormea ​​napsauttamalla, sulje kätesi tarttuaksesi ja käännä kämmentäsi itseäsi kohti ja nipistä avataksesi valikon. Paritettujen Joy-Con-ohjainten kanssa kamera seuraa niiden sijaintia, kun taas Joy-Con-ohjaimet tarjoavat pyöritystä ja painikesyötteitä. Kuvia käsitellään tällä laitteella eikä niitä koskaan tallenneta tai lähetetä. Takakamera Suositellaan. Yleensä tarkempi ja laajempi. Etukamera @@ -2426,7 +2426,7 @@ Käytä kameraa Ei nyt Käden seuranta kameralla - Kun ohjainta ei ole yhdistetty, käsistäsi tulee VR-kädet: napsauta nipistämällä ja avaa valikko nipistämällä kämmen itseäsi kohti. Joy-Conien kanssa se sijoittaa ne sinne, missä kamera ne näkee. Kuvat pysyvät tällä laitteella. + Käytä puhelimen kameraa paljain käsin tehtäviin eleisiin tai pariliitettyjen Joy-Con-ohjainten asemointiin VR:ssä. Joy-Con-ohjaimet tarjoavat kierto- ja painikesyötteitä. Seuranta keskeytyy, kun älylasit seuraavat käsiäsi tai Joy-Con-ohjaimiasi. Kuvia käsitellään vain tässä laitteessa. Kamera Kameran käyttöoikeus Salli kameran käyttö, jotta käden seuranta voi käynnistyä. @@ -2680,4 +2680,208 @@ Muunnetaan %1$s Steamille. Pidä DroidDeck auki. Laite ei pysty purkamaan videota. Videon tuonti epäonnistui + Luma Ultra -kamerat — Kokeellinen + Joy-Con-paikan seuranta + Käytä älylasien kameroita pariliitettyjen Joy-Con-ohjainten asemointiin. Kierto- ja painikesyötteet tulevat Joy-Con-ohjaimista. Sijainti arvioidaan, kun ranteesi ovat piilossa. Korvaa paljain käsin käytettävät ohjaimet ja keskeyttää puhelimen kameran seurannan. Osoita Joy-Con-ohjaimet eteenpäin, kun yhdistät tai nollaat seurantakeskuksen. + Ota ensin käyttöön sijainnin seuranta. Vaatii liiketunnistuksella varustetut Joy-Con-ohjaimet Android 12:ssa tai uudemmassa käyttöjärjestelmässä. Oletusarvoisesti pois päältä. + Älylasit + Näyttö- ja päänseuranta-asetukset jaetaan DroidDeck-valikoiden, pelien ja työpöytäistuntojen välillä. + Yhdistä älylasit muuttaaksesi niiden näyttö- ja seuranta-asetuksia. Tallennetut asetuksesi säilyvät, kun irrotat yhteyden. + VR + Näyttötila + 2D-ulostulo + 3D-ulostulo + Kuva ja virtuaalinäyttö + Sijainti ja lattiataso + Käsien seuranta — Kokeellinen + Seurannan tila + 2D-resoluutio + 3D-resoluutio + VR-resoluutio + Automaattinen + Sama kuin 2D / 3D + Lähtöresoluutio silmää kohden. + Ota käyttöön älylasien pelitoiminto valitaksesi näytön natiivin 30 Hz:n tilan. + 3DoF-virtuaalinäyttö + Ankkuroi tasaiset pelit eteesi, jotta voit katsella ympärillesi. Mahdollistaa älylasien pelitoiminnon ilman 3D-tilaan vaihtamista. + Leveys ja etäisyys päivittävät seuratun virtuaalinäytön DroidDeck-valikoissa, peleissä ja työpöytäistunnoissa välittömästi. + Sijainnin seuranta sisältää pään kierron SteamVR:ssä. Jos haluat vain kierron seurannan, poista sijainnin seuranta käytöstä. + Ohjaa pään liikettä virtuaalinäytöllä. Sijainnin seuranta sisältää pään kierron SteamVR:ssä. + Pikatoiminnot + Katso, mihin haluat näytön sijoittuvan, ja nollaa sitten seurantakeskus asettaaksesi sen korkeuden ja suunnan. + Keskitä Joy-Con-ohjaimet uudelleen + Puhelimen kamera — Kokeellinen + Käsien tai Joy-Con-ohjainten seuranta + 6DoF-virtuaalinäyttö + Sijainnin seuranta — kokeellinen + Fyysinen liike VR:ssä ja virtuaalinäyttöjen ympärillä. Seurannan uudelleenkäynnistäminen kestää hetken. + Nykyinen silmien korkeus lattiasta + Aseta lattiataso nykyisestä korkeudesta + Aseta lattiataso + Stereokameran asetukset ja diagnostiikka + Tarkista kameran kalibrointi ja käsien seuranta ennen pelaamista. + Avaa asetukset + Paljain käsin käytettävät ohjaimet + Käytä älylasien kameroita tähtäämiseen käsilläsi, nipistämällä klikkaamiseen ja sulkemalla kätesi tarttumiseen VR:ssä. Peliohjaimen sauvat liikkuvat ja kääntyvät. Korvaa Joy-Con-paikan seurannan. Seuranta voi viiveellä tai kadota pelien aikana. + Ota käyttöön paljain käsin käytettävät ohjaimet Luma Ultra -kameroiden alla Seurannassa. Näytä avoimet kädet ensin. + Jaettu Luma Ultra -kalibrointi + Jaetun Luma Ultra -jalustan käyttö. Kalibroi omat älylasisi varmistaaksesi niiden tarkkuuden. + Mitattu kalibrointi vahvistettu + Vahvistus vaaditaan + Paljain käsin käytettävät ohjaimet tulevat saataville, kun mitattu etäisyystarkistus on suoritettu. + Seuranta menetetty + Katsele hitaasti ympärillesi hyvin valaistussa huoneessa.\nPidä seurantakameroiden näkymä esteettömänä ja katso huonekaluja tai muita näkyviä yksityiskohtia kohti. + Oletko edelleen jumissa? Puhelimessa: älylasit → Seuranta → Avaa asetukset → Näytä diagnostiikka → Aloita seuranta uudelleen. + Älylasit irrotettu + Tarkista USB-yhteys ja yhdistä älylasit uudelleen.\nHyväksy puhelimesi USB-käyttökehote, jos se tulee näkyviin. + Kun yhteys on muodostettu, katso hitaasti ympärillesi hyvin valaistussa huoneessa jäljityksen palauttamiseksi. + Uudelleenkeskitys tarvitaan + Seuranta on palannut uuteen sijaintiin.\nKatso eteenpäin ja napauta sitten \"nollaa seurantakeskus\" puhelimessasi. + Seurantakeskuksen nollaus löytyy myös kohdasta älylasit → Seuranta → Avaa asetukset. Tallennettu kameran kalibrointi säilytetään. + Pysy paikallaan hetki + Seurantakeskuksen nollaus on käynnissä.\nPidä älylasit paikoillaan seurannan vakiintumisen ajan. + Tämä näyttö sulkeutuu automaattisesti, kun pään seuranta on valmis. + Stabiloitu tähtäys käsillä + Tähtää olkapäältä kämmenen läpi. Sammuta ranteella ohjattua pyöritystä varten. + Tila-asetukset + Odotetaan seurantaa… + Vasen ja oikea seurantakamera + Kameran synkronointi + Valmis + Odotetaan kameran ja päänseurannan linjaamista. Pidä älylasit kytkettynä. + 1. Valmistele kalibrointikohde + Tulosta todellisessa koossa + Jokaisen neliön on oltava kooltaan 30 mm (1,181 tuumaa). Asenna arkki tasaisesti jäykälle alustalle hyvin valaistulle alueelle. + Tulosta kalibrointikuvio + 2. Tallenna erilaisia näkymiä + Pidä kalibrointikohde paikallaan + Siirrä älylaseja lähemmäs, kauemmas ja sivuttain. Käännä niitä vasemmalle/oikealle, kallista niitä ylös/alas ja kallista sivuttain. Pidä kalibrointikohde molemmissa kameroissa ja keskeytä hetki ennen jokaista kuvausta. + Aloita uusi kalibrointi + Odotetaan kameran synkronointia. + Aloita uusi kalibrointi näkymien keräämiseksi. + Pidä kalibrointitavoite näkyvissä molemmissa esikatseluissa. Tallenna vähintään 24 terävää näkymää eri kulmista. + Kuvataan… + Kaappaa kalibroinnin kohdenäkymä + Laske kameran kohdistus + Lasketaan… + Laske kalibrointi + 3. Tarkista etäisyys + Mitattu etäisyys + Aloita 12 tuumasta tai 30 cm:stä, jotta painetut merkit on helpompi havaita. Valitse tarkka mitta, jota käytät. + Vasemman kameran ja kalibrointikohteen keskipisteen välinen etäisyys + Tarkistetaan etäisyyttä… + Vahvista etäisyys + Diagnostiikka + Näytä diagnostiikka + Kameran ajoituksen ja seurannan palautustyökalut. + Kameran ajoitus + Syöttö käsien seurannasta + Odotetaan kameran ajoitusta. + Kamerakuvat + GPU-käsien tunnistus + CPU on oletusarvo. GPU on kokeellinen ja voi saada SteamVR:n käynnistymään uudelleen. Tämä valinta nollautuu, kun seuranta käynnistetään uudelleen. + Käsimallien kevyt tunnistus + Käytä Lite-kämmenilmaisinta ja Lite-avainpisteitä käsissä. Tarkista kohdistus, puristus ja tartuntatarkkuus. Nollautuu, kun seuranta käynnistyy uudelleen. + Automaattinen syöttötaajuus käsien seurantaan + Säädä tulo prosessointinopeuden mukaan. Nollautuu, kun seuranta käynnistyy uudelleen. + Rajoita tulotaajuutta käsien seurannassa + Käytä puolet kameran kuvista. Sammuta, jos haluat verrata enimmäistaajuutta. Nollautuu, kun seuranta käynnistyy uudelleen. + Diagnostinen sieppaus + Tallenna yksi stereokuvapari paikallisesti. Kuvat tallennetaan vain pyydettäessä. + Tallenna kamerakuva + Aloita seuranta uudelleen + Käytä, jos seuranta ei palaudu hyvin valaistulla alueella. Uudelleenkäynnistys vaatii uuden seurantalähteen. + Käynnistä uudelleen + Aloitetaanko seuranta uudelleen? + Tallentamattomat kalibrointinäkymät menetetään. Pidä älylasit paikoillaan tämän jälkeen ja nollaa seurantakeskus, kun seuranta on palautettu. + %1$d / 24 katselukertaa + Kuvaus keskeytetty: %1$s + Toimenpide %1$s. Näytä täydellinen kalibrointikohde molemmissa esikatseluissa ja pidä sitten paikallaan. + %1$.1f Hz • kuvan ikä %2$.1f ms • käsittely %3$.1f ms + Tuloraja %1$.1f Hz • %2$.0f%% kamerakuvia. Pään seuranta jatkuu maksimitaajuudellaan. + %1$d käsitelty • %2$d pudonnut • %3$d ohitettu syöttörajan mukaan + DroidDeck ChArUco 30 mm + DroidDeck – Luma Ultra -kalibrointi + Tulosta 100% / todellinen koko. Jokainen neliö: 30 mm (1,181 tuumaa). + Pidä kalibrointikohde tasaisena ja paikallaan; siirrä älylaseja kuvausten välillä. + Mittakaavatarkistus: 100 mm (3,937 tuumaa) punkkien välillä + 12 tuumaa (30,48 cm) + 30 cm (11,81 tuumaa) + 20 tuumaa (50,8 cm) + 50 cm (19,69 tuumaa) + Ei käytössä + Odotetaan vakaata seurantaa + Yhteys katkaistu + Paljain käsin ohjattavat ohjaimet ovat pois päältä + Paikanseuranta on pois päältä tai älylasit on irrotettu + Seurantakeskuksen nollausta pyydetty – pidä paikallasi, kun seuranta vakautuu. + Seuranta menetetty – kohtaa hyvin valaistu alue, jossa on näkyviä yksityiskohtia + Seurannan lähtöpiste muuttunut – napauta seurantakeskuksen nollausta ja pidä sitten paikallasi. + 6DoF aktiivinen + Liitä Luma Ultra ja ota sijainnin seuranta käyttöön. + Tämän yhteyden kalibrointi on vahvistettu. + Kalibrointi vahvistettu ja tallennettu. + Odotetaan stereokameroita + Odotetaan käsien seurantaa + Pidä 5 × 7 -kalibrointitavoite paikallaan. Tallenna yli 24 näkymää liikuttamalla ja pyörittämällä älylaseja. + Odotetaan seuraavaa kamerakuvaa. Pidä älylasit paikallaan. + Tarkistetaan seuraavaa kamerakuvaa. Pidä koko kalibrointitavoite näkyvissä ja pidä paikallaan. + Aloita kalibrointi ensin + Uusi kamerakuva ei saapunut. Tarkista älylasien yhteys ja kameran esikatselu ja yritä sitten uudelleen. + Kameran kellon nollaus + Seurantakoordinaatisto muuttunut. Näkymäsi tallennetaan uudelleenlaskentaa varten. Nollaa seurantakeskus ja aloita uusi sarja useampien näkymien tallentamiseksi. + laitteen kalibrointi ladattu + Luma Ultra -peruskalibrointi ladattu + kalibrointi vaaditaan + Napauta Aloita uusi kalibrointi ensin. + Seurantakeskuksen nollaus odottaa vakaata seurantaa. Pysy paikallasi hetki. + Seuranta muuttunut. Napauta seurantakeskuksen nollausta kerran ja pidä sitten paikallasi ennen kuvaamista. + Kuvaus hylätty: pään seuranta ei ollut synkronoitu tai se muuttui kuvauksen aikana. Pysy paikallasi ja yritä uudelleen. + Laske kameran kohdistus ennen etäisyyden tarkistamista. + Kameran käsittely epäonnistui + Pään seuranta muuttui käsien havaitsemisen aikana + Odotetaan kameran ja pään synkronointia + Ranteita ei havaittu. Pidä Joy-Con-ohjaimesi kahvat älylasien edessä + Käsiä ei havaittu. Näytä avoimet kämmenet älylasien edessä + Ranteet näkyvät vain yhdessä kamerassa; pidä ohjaimen kahvat jaetussa näkymässä + Kädet näkyvät vain yhdessä kamerassa; pidä molemmat kämmenet yhteisessä näkymässä + Molemmat kamerat näkevät kädet, mutta vasen/oikea vastaavuus on epäselvä + Kädet havaittu, mutta stereosyvyys on epäjohdonmukainen + Ranteen asento hylätty stereo- tai liiketarkistuksella + Stereopisteet havaittu, mutta kämmengeometria on epäjohdonmukainen + Suorita kalibrointi ja etäisyyden tarkistus käsien mahdollistamiseksi + Odotetaan vakaata pään seurantaa; nollaa seurantakeskus pyydettäessä. + Kamerahavainto on liian vanha; uutta paria odotellessa + Sovita %1$.2f px. Mittaa valitsemasi etäisyys vasemmasta kamerasta kalibrointikohteen keskustaan ​​ja vahvista sitten. + OpenCV ei saatavilla: %1$s + %1$d tallennettua näkymää palautettu. Laske kalibrointi yrittääksesi uudelleen tai aloita uusi sarja, jos haluat ottaa lisää. + Kuvattu %1$d / 24 katselukertaa. Pidä kalibrointitavoite kiinteänä; siirrä älylaseja seuraavaa näkymää varten. + Kuvaus hylätty: %1$d / 12 vaadittua kulmaa näkyvissä molemmissa kameroissa. Näytä lisää kalibrointikohdetta, pidä paikallaan ja yritä sitten uudelleen. + Etäisyyden tarkistusta ei voitu suorittaa loppuun: %1$s. Yritä uudelleen. + Käsien tunnistus ei ole käytettävissä: %1$s. Vaihda CPU/GPU tai vaihda ohjaimia, joita käytetään paljain käsin, jotta voit yrittää uudelleen. + Käsien tunnistus ylitti %1$d ms; havainto hylätty + %1$d / 2 Joy-Con-ranteen asentoa stereolla mitattuna + Seuratut kämmenet: %1$d / 2; nipistysele valmis: %2$d; tarttumaele valmis: %3$d + Tallennettu diagnostiikkakaappaus kohteeseen %1$s + Käsien seuranta pysäytetty: %1$s + Stereo %1$d×%2$d; %3$s + Pään seuranta ja kalibrointitavoite eroavat toisistaan %1$s:lla (raja 5 cm / 2 tuumaa). Pidä kalibrointitavoite kiinteänä ja odota tasaista seurantaa ennen uuden sarjan aloittamista. Käännä ja kallista älylaseja varovasti; tauko ennen jokaista sieppausta. + Tallenna vähintään 24 erilaista näkymää paikallaan olevasta kalibrointikohteesta. + Käännä älylaseja vasemmalle ja oikealle ja kallista niitä ylös ja alas; liike ilman pyöritystä ei voi kalibroida kameran kohdistusta. + Epäuskottava kameran perusviiva + Liikuta päätäsi monipuolisemmissa asennoissa. + Virheellinen kameran ja pään välinen kierto + Kameran ja pään välinen kohdistus on epäjohdonmukainen. + Kalibrointia ei voitu suorittaa loppuun. %1$s Tallennetut näkymät tallennetaan. + Pidätetty toistovirhe %1$.2f px ylittää 2 pikseliä. Kalibroi uudelleen. + %1$d / 24 shakkilaudan kulmaa havaittu molemmissa kameroissa. Pidä koko kalibrointitavoite näkyvissä ja pidä paikallaan. Jos se on jo näkyvissä, valitse 12 tuumaa tai 30 cm ja mittaa lähempi etäisyys ennen kuin yrität uudelleen. + Kalibrointikohde on näkyvissä, mutta sen syvyyttä ei voitu mitata luotettavasti. Pidä älylaseja paikallaan ja pidä kalibrointikohde tasaisena ja hyvin valaistuna. Yritä sitten uudelleen. + Kameran mittaus oli virheellinen. Pysy paikallaan ja yritä uudelleen. + Etäisyystarkastus läpäisty. + Tarkista etäisyys vasemmasta kamerasta kalibrointikohteen keskustaan ​​ja yritä sitten uudelleen. + Kamerat mitattu %1$s; valittu etäisyys %2$s. %3$s + Odota molempien kameroiden esikatselua ennen kalibroinnin aloittamista. + Tallennetut näkymät voidaan laskea uudelleen. Aloita uusi kalibrointi kaapataksesi nykyiseen seurantakoordinaattijärjestelmään. + Käsimallin tarkistussumman epäsuhta + OpenCV:tä ei voitu ladata diff --git a/app/src/main/res/values-fr/strings.xml b/app/src/main/res/values-fr/strings.xml index 791475a185..5d2323f912 100644 --- a/app/src/main/res/values-fr/strings.xml +++ b/app/src/main/res/values-fr/strings.xml @@ -2385,14 +2385,14 @@ Affichage Fréquence d\'affichage 3D (côte à côte) - Chaque œil reçoit sa propre moitié d\'une image de 3840×1080. Si l\'image disparaît, maintenez le bouton 2D/3D des lunettes. + Basculer les lunettes intelligentes en mode 3D côte à côte. Le suivi de la tête est contrôlé séparément. Le signal 3D n\'a pas été confirmé. Réessayez une fois l\'image 2D rétablie. Pas d\'image : les lunettes sont dans un mode que ce téléphone ne peut pas envoyer. Maintenez leur bouton 2D/3D, ou débranchez-les puis rebranchez-les. Fréquence en 3D 3D pour les jeux VR Passe en 3D pendant que SteamVR tourne, puis revient ensuite. - Image 3D - Automatique : SteamVR remplit la vue ; les autres jeux flottent comme un écran en 3D et restent plats en 2D. + Image + Affichage automatique du contenu plat pour les deux yeux et détection de SteamVR. Choisissez « Jeu côte à côte » pour le contenu SBS. Automatique Écran virtuel Jeu côte à côte @@ -2402,20 +2402,20 @@ Ces réglages s\'appliquent lorsque Jeu sur les lunettes est activé et que le jeu y est affiché. Automatique garde ce jeu 2D en plein écran. Utilisez un écran virtuel pour régler sa largeur, sa distance et le suivi de la tête. Utiliser l\'écran virtuel - SteamVR remplit la vue. Réglez son champ de vision ci-dessous ; la largeur et la distance ne s\'appliquent qu\'à un écran virtuel. + SteamVR remplit le champ de vision. Ajustez son champ de vision en VR ; la largeur et la distance s’appliquent uniquement à l’écran virtuel. Les jeux côte à côte remplissent chaque œil. La largeur et la distance ne s\'appliquent qu\'à un écran virtuel. Automatique garde ce jeu 2D fixe dans la vue. Choisissez Écran virtuel dans Affichage pour utiliser le suivi de la tête. Le suivi de la tête s\'applique à un écran virtuel ou à un jeu SteamVR en cours. - Lunettes + Appareil Luminosité Volume Pare-soleil Assombrit les verres avant. - Suivi de la tête + Suivi Suivi de la tête Les capteurs des lunettes font tourner l\'écran virtuel et SteamVR avec votre tête. Recentrer la vue - Recentrer + Recentrer l’écran Champ de vision SteamVR Plus bas rapproche SteamVR et remplit les lunettes ; plus haut montre davantage autour de vous. En jeu sur %1$s @@ -2436,8 +2436,8 @@ Supprimer le calibrage enregistré et rétablir les valeurs par défaut du modèle ? Recentrez après avoir remis les lunettes. Réinitialiser Suivi des mains - Suivre vos mains avec la caméra ? - La caméra peut voir vos mains. Sans manette connectée, vos mains nues deviennent les mains VR : pincez le pouce et l\'index pour cliquer, fermez la main pour saisir, et tournez la paume vers vous puis pincez pour ouvrir le menu. Avec des Joy-Con, elle les place là où se trouvent vraiment vos mains. Les images sont traitées sur cet appareil et ne sont jamais enregistrées ni envoyées. + Suivi des mains ou des manettes Joy-Con avec la caméra du téléphone ? + Sans manette connectée, la caméra du téléphone suit vos mains nues en VR : pincez votre pouce et votre index pour cliquer, fermez la main pour saisir un objet, et tournez la paume vers vous et pincez pour ouvrir le menu. Avec des manettes Joy-Con connectées, la caméra suit leur position tandis que les manettes permettent la rotation et l\'utilisation des boutons. Les images sont traitées sur cet appareil et ne sont ni enregistrées ni envoyées. Caméra arrière Recommandée. Généralement plus nette et plus large. Caméra avant @@ -2445,7 +2445,7 @@ Utiliser la caméra Pas maintenant Suivi des mains par caméra - Sans manette connectée, vos mains deviennent les mains VR : pincez pour cliquer, paume vers vous et pincez pour le menu. Avec des Joy-Con, elle les place là où la caméra les voit. Les images restent sur cet appareil. + Utilisez la caméra du téléphone pour les gestes à mains nues ou pour positionner les manettes Joy-Con appariées en VR. Les manettes Joy-Con permettent la rotation et les entrées des boutons. Interrompt le suivi pendant que les lunettes connectées suivent vos mains ou les manettes Joy-Con. Les images sont traitées uniquement sur cet appareil. Caméra Accès à la caméra Autorisez l\'accès à la caméra pour démarrer le suivi des mains. @@ -2705,4 +2705,208 @@ Conversion de %1$s pour Steam. Gardez DroidDeck ouvert. Cet appareil ne peut pas décoder cette vidéo. Impossible d\'importer cette vidéo + Caméras Luma Ultra — Expérimental + Suivi de la position des Joy-Con + Utilisez les caméras des lunettes connectées pour positionner vos manettes Joy-Con appariées. La rotation et les entrées des boutons proviennent des manettes Joy-Con. La position est estimée lorsque vos poignets sont cachés. Remplace les manettes utilisées à mains nues et interrompt le suivi par la caméra du téléphone. Pointez les manettes Joy-Con vers l\'avant lors de la connexion ou de la réinitialisation du centre de suivi. + Activez d\'abord le suivi de position. Nécessite des manettes Joy-Con compatibles avec la détection de mouvements sous Android 12 ou version ultérieure. Désactivé par défaut. + Lunettes connectées + Les paramètres d\'affichage et de suivi de la tête sont partagés entre les menus DroidDeck, les jeux et les sessions de bureau. + Connectez vos lunettes connectées pour modifier leurs paramètres d\'affichage et de suivi. Vos paramètres enregistrés sont conservés lors de la déconnexion. + VR + Mode d\'affichage + Sortie 2D + Sortie 3D + Image et écran virtuel + Position et niveau du sol + Suivi des mains — Expérimental + État du suivi + Résolution 2D + Résolution 3D + Résolution VR + Automatique + Identique à 2D/3D + Résolution de sortie par œil. + Activer le mode Jeu sur lunettes intelligentes pour sélectionner le mode 30 Hz natif de l\'écran. + Écran virtuel 3DoF + Ancrer les jeux plats devant vous pour vous permettre de regarder autour de vous. Active le mode Jeu sur lunettes intelligentes sans passer en 3D. + Largeur et distance : mise à jour immédiate de l’écran virtuel suivi pour les menus DroidDeck, les jeux et les sessions de bureau. + Le suivi de position inclut la rotation de la tête dans SteamVR. Pour un suivi de la rotation uniquement, désactivez le suivi de position. + Contrôle les mouvements de la tête sur l’écran virtuel. Le suivi de position inclut la rotation de la tête dans SteamVR. + Actions rapides + Regardez où vous souhaitez que l\'écran apparaisse, puis réinitialisez le centre de suivi pour définir sa hauteur et sa direction. + Recentrer les Joy-Con + Caméra du téléphone — Expérimental + Suivi des mains ou des manettes Joy-Con + Écran virtuel 6DoF + Suivi de position — expérimental + Mouvements physiques en VR et autour des écrans virtuels. Le redémarrage du suivi peut prendre quelques instants. + Hauteur actuelle des yeux par rapport au sol + Définir le niveau du sol à partir de la hauteur actuelle + Définir le niveau du sol + Configuration et diagnostic de la caméra stéréo + Vérifiez l\'étalonnage de la caméra et le suivi des mains avant de jouer. + Ouvrir la configuration + Manettes utilisées à mains nues + Utilisez les caméras des lunettes intelligentes pour viser avec vos mains, pincer pour cliquer et fermer la main pour saisir en VR. Les joysticks de la manette bougent et tournent. Remplace le suivi de position des Joy-Con. Peut entraîner des latences ou des pertes de suivi pendant les jeux. + Activer l\'utilisation des manettes à mains nues sous les caméras Luma Ultra dans Suivi. Afficher d\'abord les mains ouvertes. + Étalonnage Luma Ultra partagé + Utilisation de la base Luma Ultra partagée. Calibrez vos lunettes connectées pour vérifier leur précision. + Calibrage mesuré vérifié + Validation requise + Les manettes utilisables à mains nues sont disponibles une fois la vérification de distance effectuée. + Suivi perdu + Regardez lentement autour de vous dans une pièce bien éclairée.\nAssurez-vous que les caméras de suivi sont dégagées et que vous êtes face à des meubles ou à d\'autres éléments visibles. + Toujours bloqué ? Sur votre téléphone : lunettes intelligentes → Suivi → Ouvrir la configuration → Afficher les diagnostics → Redémarrer le suivi. + Lunettes intelligentes déconnectées + Vérifiez la connexion USB et reconnectez les lunettes intelligentes.\nAcceptez l\'invite d\'accès USB sur votre téléphone si elle apparaît. + Une fois connecté, regardez lentement autour de vous dans une pièce bien éclairée pour rétablir le suivi. + Recentrage nécessaire + Le suivi a repris dans une nouvelle position.\nRegardez devant vous, puis appuyez sur « Réinitialiser le centre de suivi » sur votre téléphone. + Vous pouvez également réinitialiser le centre de suivi dans Lunettes connectées → Suivi → Ouvrir la configuration. Votre étalonnage de caméra enregistré est conservé. + Restez immobile un instant + Réinitialisation du centre de suivi en cours.\nGardez les lunettes connectées immobiles pendant la stabilisation du suivi. + Cet écran se ferme automatiquement lorsque le suivi de la tête est prêt. + Visée stabilisée avec les mains + Visez depuis votre épaule à travers votre paume. Éteignez-le pour une rotation contrôlée par le poignet. + Configuration spatiale + En attente de suivi… + Caméras de suivi gauche et droite + Synchronisation de la caméra + Prêt + En attente que la caméra et le suivi de la tête s\'alignent. Gardez les lunettes intelligentes connectées. + 1. Préparez la cible d\'étalonnage + Imprimer à taille réelle + Chaque carré doit mesurer 30 mm (1,181 po). Montez la feuille à plat sur une surface rigide dans un endroit bien éclairé. + Imprimer la mire d’étalonnage + 2. Capturer différentes vues + Maintenir la cible d\'étalonnage stationnaire + Rapprochez, éloignez et latéralement les lunettes intelligentes. Tournez-les à gauche/droite, inclinez-les vers le haut/bas et inclinez-les sur le côté. Conservez la cible d\'étalonnage dans les deux caméras et faites une brève pause avant chaque capture. + Démarrer un nouvel étalonnage + En attente de synchronisation de la caméra. + Démarrez un nouveau calibrage pour collecter des vues. + Gardez la cible d\'étalonnage visible dans les deux aperçus. Capturez au moins 24 vues nettes sous différents angles. + Capturer… + Capturer la vue cible d\'étalonnage + Calculer l\'alignement de la caméra + Calcul… + Calculer l\'étalonnage + 3. Vérifiez la distance + Distance mesurée + Commencez par 12 pouces ou 30 cm pour que les marqueurs imprimés soient plus faciles à détecter. Choisissez la mesure exacte que vous utiliserez. + Caméra gauche vers le centre de la cible d\'étalonnage + Vérification de la distance… + Valider la distance + Diagnostic + Afficher les diagnostics + Outils de synchronisation et de récupération de suivi de la caméra. + Synchronisation de la caméra + Entrée du suivi des mains + En attente du timing de la caméra. + Images de la caméra + Détection GPU des mains + Le CPU est utilisé par défaut. Le GPU est expérimental et peut provoquer un redémarrage de SteamVR. Ce choix est réinitialisé au redémarrage du suivi. + Détection légère des modèles de mains + Utilisez le détecteur de paume Lite et les points clés Lite sur les mains. Vérifiez la précision de la visée, du pincement et de la saisie. Se réinitialise lors du redémarrage du suivi. + Fréquence d\'entrée automatique pour le suivi des mains + Ajustez l\'entrée à la vitesse de traitement. Se réinitialise lors du redémarrage du suivi. + Limiter la fréquence d\'entrée pour le suivi des mains + Utilisez la moitié des images de la caméra. Éteignez pour comparer la fréquence maximale. Se réinitialise lors du redémarrage du suivi. + Capture diagnostique + Enregistrez localement une paire d’images stéréo. Les images sont enregistrées uniquement sur demande. + Enregistrer l\'image de la caméra + Redémarrer le suivi + À utiliser si le suivi ne se rétablit pas dans une zone bien éclairée. Un redémarrage nécessite une nouvelle origine de suivi. + Redémarrer + Redémarrer le suivi ? + Les vues d\'étalonnage non enregistrées seront perdues. Gardez les lunettes connectées immobiles ensuite et réinitialisez le centre de suivi une fois le suivi rétabli. + %1$d / 24 vues capturées + Capture interrompue : %1$s + Mesure %1$s. Affichez la cible d\'étalonnage complète dans les deux aperçus, puis restez immobile. + %1$.1f Hz • âge de l\'image %2$.1f ms • traitement %3$.1f ms + Limite d\'entrée %1$.1f Hz • %2$.0f%% des images de la caméra. Le suivi de la tête continue à sa fréquence maximale. + %1$d traité • %2$d supprimé • %3$d ignoré par limite d\'entrée + DroidDeck ChArUco 30 mm + DroidDeck - Calibrage Luma Ultra + Imprimer à 100% / Taille réelle. Chaque carré : 30 mm (1,181 po). + Gardez la cible d\'étalonnage à plat et stationnaire ; déplacez les lunettes intelligentes entre les captures. + Vérification de l\'échelle : 100 mm (3,937 in) entre les graduations + 12 pouces (30,48 cm) + 30 cm (11,81 pouces) + 20 po (50,8 cm) + 50 cm (19,69 pouces) + Désactivé + En attente d\'un suivi stable + Déconnecté + Les contrôleurs actionnés à mains nues sont éteints + Le suivi de position est désactivé ou les lunettes intelligentes sont déconnectées + Réinitialisation du centre de suivi demandée — restez immobile pendant la stabilisation du suivi. + Suivi perdu – faites face à une zone bien éclairée avec des détails visibles + Origine du suivi modifiée — appuyez sur Réinitialiser le centre de suivi, puis restez immobile. + 6DoF actif + Connectez Luma Ultra et activez le suivi de position. + Calibrage vérifié pour cette connexion. + Calibrage vérifié et enregistré. + En attente des caméras stéréo + En attente du suivi des mains + Gardez la cible d\'étalonnage 5 × 7 stationnaire. Capturez plus de 24 vues tout en déplaçant et en faisant pivoter les lunettes intelligentes. + En attente de la prochaine image de la caméra. Tenez immobile les lunettes intelligentes. + Vérification de l\'image suivante de la caméra. Gardez la cible d\'étalonnage complète visible et restez immobile. + Commencer d\'abord l\'étalonnage + Aucune nouvelle image de caméra n’est arrivée. Vérifiez la connexion des lunettes intelligentes et les aperçus de l\'appareil photo, puis réessayez. + Réinitialisation de l\'horloge de l\'appareil photo + Système de coordonnées de suivi modifié. Vos vues sont enregistrées pour recalcul. Réinitialisez le centre de suivi, puis lancez une nouvelle série pour capturer davantage de vues. + étalonnage de l\'appareil chargé + Calibrage de base Luma Ultra chargé + étalonnage requis + Appuyez d\'abord sur Démarrer un nouvel étalonnage. + La réinitialisation du centre de suivi attend un suivi stable. Restez immobile un instant. + Suivi modifié. Appuyez une fois sur Réinitialiser le centre de suivi, puis restez immobile avant de capturer. + Capture rejetée : le suivi de la tête était désynchronisé ou a changé pendant la capture. Restez immobile et réessayez. + Calculez l\'alignement de la caméra avant de vérifier la distance. + Échec du traitement de la caméra + Le suivi de la tête a changé lors de la détection des mains + En attente de synchronisation de la caméra et de la tête + Aucun poignet détecté. Gardez les poignées de votre contrôleur Joy-Con devant les lunettes intelligentes + Aucune main détectée. Montrez les paumes ouvertes devant les lunettes intelligentes + Poignets visibles dans une seule caméra ; gardez les poignées de votre contrôleur dans la vue partagée + Mains visibles dans une seule caméra ; garder les deux paumes dans la vue partagée + Les deux caméras voient les mains, mais la correspondance gauche/droite est ambiguë + Mains détectées, mais la profondeur stéréo est incohérente + Position du poignet rejetée par les contrôles stéréo ou de mouvement + Points stéréo détectés, mais la géométrie de la paume est incohérente + Terminer l\'étalonnage et la vérification de la distance pour permettre aux mains + Attente d\'un suivi de tête stable ; réinitialisation du centre de suivi si demandé. + L\'observation par caméra est trop ancienne ; en attendant une nouvelle paire + Ajuster %1$.2f px. Mesurez la distance sélectionnée entre la caméra gauche et le centre de la cible de calibrage, puis validez. + OpenCV indisponible : %1$s + %1$d vues enregistrées restaurées. Calculez l’étalonnage pour réessayer ou démarrez un nouvel ensemble pour en capturer davantage. + Capturé %1$d / 24 vues. Gardez la cible d\'étalonnage fixe ; déplacez les lunettes intelligentes pour la vue suivante. + Capture rejetée : %1$d / 12 coins requis visibles dans les deux caméras. Affichez davantage la cible d\'étalonnage, restez immobile, puis réessayez. + La vérification de distance n\'a pas pu se terminer : %1$s. Essayer à nouveau. + Détection de mains indisponibles : %1$s. Changez de CPU/GPU ou basculez les contrôleurs utilisés à mains nues pour réessayer. + Détection des mains dépassée %1$d ms ; observation rejetée + %1$d / 2 positions du poignet du Joy-Con mesurées en stéréo + Paumes suivies : %1$d / 2 ; pincement prêt : %2$d ; saisie prête : %3$d + Capture de diagnostic enregistrée dans %1$s + Suivi des mains arrêté : %1$s + Stéréo %1$d×%2$d ; %3$s + Le suivi de la tête et la cible d\'étalonnage sont en désaccord de %1$s (limite de 5 cm / 2 po). Gardez la cible d\'étalonnage fixe et attendez un suivi stable avant de commencer un nouvel ensemble. Tournez et inclinez doucement les lunettes intelligentes ; faites une pause avant chaque capture. + Capturez au moins 24 vues variées de la cible d\'étalonnage stationnaire. + Tournez les lunettes intelligentes à gauche et à droite et inclinez-les de haut en bas ; un mouvement sans rotation ne peut pas calibrer l’alignement de la caméra. + Base de référence de la caméra invraisemblable + Déplacez votre tête dans des orientations plus variées. + Rotation caméra-tête non valide + L\'alignement caméra-tête est incohérent. + L\'étalonnage n\'a pas pu se terminer. %1$s Vos vues capturées sont enregistrées. + L\'erreur de reprojection suspendue %1$.2f px dépasse 2 px. Recalibrer. + %1$d / 24 coins en damier détectés dans les deux caméras. Gardez la cible d\'étalonnage complète visible et restez immobile. S\'il est déjà visible, sélectionnez 12 pouces ou 30 cm et mesurez cette distance la plus proche avant de réessayer. + La cible d\'étalonnage est visible, mais sa profondeur n\'a pas pu être mesurée de manière fiable. Maintenez les lunettes intelligentes immobiles et gardez la cible d\'étalonnage plate et bien éclairée, puis réessayez. + Les mesures de la caméra n\'étaient pas valides. Restez immobile et réessayez. + Contrôle de distance réussi. + Revérifiez la distance entre la caméra gauche et le centre de la cible d\'étalonnage, puis réessayez. + Caméras mesurées %1$s ; distance sélectionnée %2$s. %3$s + Attendez les deux aperçus de la caméra avant de commencer l\'étalonnage. + Les vues enregistrées peuvent être recalculées. Démarrez un nouvel étalonnage pour capturer dans le système de coordonnées de suivi actuel. + Incohérence de la somme de contrôle du modèle manuel + OpenCV n\'a pas pu charger diff --git a/app/src/main/res/values-hi/strings.xml b/app/src/main/res/values-hi/strings.xml index a5ded04c16..556e2b5382 100644 --- a/app/src/main/res/values-hi/strings.xml +++ b/app/src/main/res/values-hi/strings.xml @@ -2366,14 +2366,14 @@ डिस्प्ले रिफ्रेश रेट 3D (साइड-बाय-साइड) - हर आंख को 3840×1080 तस्वीर का अपना आधा हिस्सा मिलता है। अगर तस्वीर चली जाए, तो चश्मे का 2D/3D बटन दबाकर रखें। + स्मार्ट ग्लास को साइड-बाय-साइड 3D पर स्विच करें। हेड ट्रैकिंग को अलग से कंट्रोल किया जाता है। 3D सिग्नल की पुष्टि नहीं हुई। 2D तस्वीर वापस आने पर फिर कोशिश करें। कोई तस्वीर नहीं: चश्मा ऐसे मोड में है जिसे यह फ़ोन नहीं भेज सकता। उसका 2D/3D बटन दबाकर रखें, या केबल निकालकर फिर से लगाएं। 3D रिफ्रेश रेट VR गेम के लिए 3D SteamVR चलने के दौरान 3D पर चला जाता है, और बाद में वापस आ जाता है। - 3D तस्वीर - ऑटोमैटिक: SteamVR पूरा व्यू भर देता है; दूसरे गेम 3D में स्क्रीन की तरह हवा में दिखते हैं और 2D में सपाट रहते हैं। + पिक्चर + ऑटोमैटिक दोनों आँखों में फ़्लैट कंटेंट दिखाता है और SteamVR को डिटेक्ट करता है। SBS कंटेंट के लिए साइड-बाय-साइड गेम चुनें। ऑटोमैटिक वर्चुअल स्क्रीन साइड-बाय-साइड गेम @@ -2383,20 +2383,20 @@ ये सेटिंग तब लागू होती हैं जब चश्मे पर गेम चालू हो और गेम वहीं दिख रहा हो। ऑटोमैटिक इस 2D गेम को फ़ुल-स्क्रीन रखता है। इसकी चौड़ाई, दूरी और हेड ट्रैकिंग बदलने के लिए वर्चुअल स्क्रीन इस्तेमाल करें। वर्चुअल स्क्रीन इस्तेमाल करें - SteamVR पूरा व्यू भर देता है। नीचे इसका फ़ील्ड ऑफ़ व्यू बदलें; चौड़ाई और दूरी सिर्फ़ वर्चुअल स्क्रीन पर लागू होती हैं। + SteamVR व्यू को भरता है। VR में इसके फ़ील्ड ऑफ़ व्यू को एडजस्ट करें; चौड़ाई और दूरी सिर्फ़ वर्चुअल स्क्रीन पर लागू होती है। साइड-बाय-साइड गेम हर आंख का व्यू भर देते हैं। चौड़ाई और दूरी सिर्फ़ वर्चुअल स्क्रीन पर लागू होती हैं। ऑटोमैटिक इस 2D गेम को व्यू में एक जगह टिकाए रखता है। हेड ट्रैकिंग इस्तेमाल करने के लिए डिस्प्ले में वर्चुअल स्क्रीन चुनें। हेड ट्रैकिंग वर्चुअल स्क्रीन या चल रहे SteamVR गेम पर लागू होती है। - चश्मा + डिवाइस ब्राइटनेस वॉल्यूम सनब्लॉक आगे के लेंस गहरे करता है। - हेड ट्रैकिंग + ट्रैकिंग हेड ट्रैकिंग चश्मे के अपने सेंसर वर्चुअल स्क्रीन और SteamVR को आपके सिर के साथ घुमाते हैं। व्यू को फिर से बीच में लाएं - बीच में लाएं + स्क्रीन फिर से केंद्रित करें SteamVR फ़ील्ड ऑफ़ व्यू कम करने पर SteamVR पास आता है और चश्मा भर देता है; ज़्यादा करने पर आपके आस-पास ज़्यादा दिखता है। %1$s पर खेल रहे हैं @@ -2417,8 +2417,8 @@ सेव किया गया कैलिब्रेशन हटाकर मॉडल का डिफ़ॉल्ट वापस लाएं? चश्मा दोबारा पहनने के बाद व्यू बीच में लाएं। रीसेट करें हाथ ट्रैकिंग - क्या कैमरे से आपके हाथों को ट्रैक करें? - कैमरा आपके हाथ देख सकता है। कोई कंट्रोलर कनेक्ट न होने पर आपके खाली हाथ ही VR हाथ बन जाते हैं: क्लिक करने के लिए अंगूठे और तर्जनी को मिलाएं, पकड़ने के लिए मुट्ठी बंद करें, और मेनू खोलने के लिए हथेली अपनी ओर करके उंगलियां मिलाएं। Joy-Con के साथ, यह उन्हें वहीं रखता है जहां आपके हाथ सच में हैं। तस्वीरें इसी डिवाइस पर प्रोसेस होती हैं और कभी सेव या भेजी नहीं जातीं। + फ़ोन कैमरे से हाथ या Joy-Con कंट्रोलर ट्रैक करें? + बिना कंट्रोलर कनेक्ट किए, फ़ोन कैमरा VR में आपके खाली हाथों को ट्रैक करता है: क्लिक करने के लिए अपने अंगूठे और इंडेक्स फिंगर को पिंच करें, पकड़ने के लिए अपना हाथ बंद करें, और अपनी हथेली को अपनी ओर घुमाएं और मेनू खोलने के लिए पिंच करें। पेयर्ड Joy-Con कंट्रोलर के साथ, कैमरा उनकी पोज़िशन को ट्रैक करता है जबकि Joy-Con कंट्रोलर रोटेशन और बटन इनपुट देते हैं। पिक्चर इस डिवाइस पर प्रोसेस की जाती हैं और कभी सेव या भेजी नहीं जातीं। रियर कैमरा सुझाया गया। आमतौर पर ज़्यादा शार्प और चौड़ा। फ्रंट कैमरा @@ -2426,7 +2426,7 @@ कैमरा इस्तेमाल करें अभी नहीं कैमरे से हाथ ट्रैकिंग - कोई कंट्रोलर कनेक्ट न होने पर आपके हाथ ही VR हाथ बन जाते हैं: क्लिक के लिए उंगलियां मिलाएं, मेनू के लिए हथेली अपनी ओर करके उंगलियां मिलाएं। Joy-Con के साथ, यह उन्हें वहां रखता है जहां कैमरा उन्हें देखता है। तस्वीरें इसी डिवाइस पर रहती हैं। + नंगे हाथों से जेस्चर के लिए या VR में पेयर्ड Joy-Con कंट्रोलर्स को सही जगह पर लगाने के लिए फ़ोन कैमरे का इस्तेमाल करें। Joy-Con कंट्रोलर्स रोटेशन और बटन इनपुट देते हैं। जब स्मार्ट ग्लास आपके हाथों या Joy-Con कंट्रोलर्स को ट्रैक करते हैं, तो यह पॉज़ करता है। इमेज सिर्फ़ इसी डिवाइस पर प्रोसेस की जाती हैं। कैमरा कैमरा एक्सेस हाथ ट्रैकिंग शुरू करने के लिए कैमरा एक्सेस की अनुमति दें। @@ -2680,4 +2680,208 @@ %1$s को Steam के लिए बदला जा रहा है। DroidDeck खुला रखें। यह डिवाइस उस वीडियो को डिकोड नहीं कर सकता। वीडियो इंपोर्ट नहीं हो सका + Luma Ultra कैमरे — एक्सपेरिमेंटल + Joy-Con पोजीशन ट्रैकिंग + अपने पेयर्ड Joy-Con कंट्रोलर्स को सही जगह पर लगाने के लिए स्मार्ट ग्लास के कैमरे का इस्तेमाल करें। रोटेशन और बटन इनपुट Joy-Con कंट्रोलर्स से आते हैं। जब आपकी कलाइयां छिपी होती हैं, तो पोजीशन का अंदाज़ा लगाया जाता है। नंगे हाथों से चलने वाले कंट्रोलर्स को बदलता है और फ़ोन-कैमरा ट्रैकिंग को पॉज़ करता है। ट्रैकिंग सेंटर को कनेक्ट या रीसेट करते समय Joy-Con कंट्रोलर्स को आगे की ओर पॉइंट करें। + पहले पोजीशनल ट्रैकिंग इनेबल करें। Android 12 या उसके बाद के वर्शन पर मोशन-कैपेबल Joy-Con कंट्रोलर्स की ज़रूरत है। डिफ़ॉल्ट रूप से बंद। + स्मार्ट ग्लास + डिस्प्ले और हेड-ट्रैकिंग सेटिंग्स DroidDeck मेनू, गेम्स और डेस्कटॉप सेशन में शेयर की जाती हैं। + स्मार्ट ग्लास को उनकी डिस्प्ले और ट्रैकिंग सेटिंग्स बदलने के लिए कनेक्ट करें। जब आप डिस्कनेक्ट करते हैं तो आपकी सेव की गई सेटिंग्स रखी जाती हैं। + VR + डिस्प्ले मोड + 2D आउटपुट + 3D आउटपुट + पिक्चर और वर्चुअल स्क्रीन + पोजीशन और फ्लोर लेवल + हाथों की ट्रैकिंग — एक्सपेरिमेंटल + ट्रैकिंग स्टेटस + 2D रिज़ॉल्यूशन + 3D रिज़ॉल्यूशन + VR रिज़ॉल्यूशन + ऑटोमैटिक + 2D / 3D जैसा ही + हर आंख के लिए आउटपुट रिज़ॉल्यूशन। + डिस्प्ले का नेटिव 30 Hz मोड चुनने के लिए स्मार्ट ग्लास पर गेम चालू करें। + 3DoF वर्चुअल स्क्रीन + अपने सामने फ्लैट गेम्स को एंकर करें ताकि आप चारों ओर देख सकें। 3D पर स्विच किए बिना स्मार्ट ग्लास पर गेम चालू करता है। + चौड़ाई और दूरी, DroidDeck मेन्यू, गेम और डेस्कटॉप सेशन के लिए ट्रैक की गई वर्चुअल स्क्रीन को तुरंत अपडेट करते हैं। + SteamVR में पोज़िशनल ट्रैकिंग में हेड रोटेशन शामिल है। सिर्फ़ रोटेशन ट्रैकिंग के लिए, पोज़िशनल ट्रैकिंग को बंद करें। + वर्चुअल स्क्रीन पर हेड मूवमेंट को कंट्रोल करता है। SteamVR में पोज़िशनल ट्रैकिंग में हेड रोटेशन शामिल है। + क्विक एक्शन + स्क्रीन को जहां आप चाहते हैं वहां देखें, फिर उसकी ऊंचाई और दिशा सेट करने के लिए ट्रैकिंग सेंटर को रीसेट करें। + Joy-Con फिर से केंद्रित करें + फ़ोन कैमरा — एक्सपेरिमेंटल + हाथ या Joy-Con कंट्रोलर ट्रैक करें + 6DoF वर्चुअल स्क्रीन + पोज़िशनल ट्रैकिंग — एक्सपेरिमेंटल + VR में और वर्चुअल स्क्रीन के आस-पास फिजिकल मूवमेंट। ट्रैकिंग को फिर से शुरू करने में थोड़ा समय लगता है। + फ्लोर से अभी की आंख की ऊंचाई + अभी की ऊंचाई से फ्लोर लेवल सेट करें + फ्लोर लेवल सेट करें + स्टीरियो कैमरा सेटअप और डायग्नोस्टिक्स + खेलने से पहले कैमरा कैलिब्रेशन और हाथों की ट्रैकिंग चेक करें। + सेटअप खोलें + कंट्रोलर नंगे हाथों से ऑपरेट होते हैं + VR में अपने हाथों से निशाना लगाने, क्लिक करने के लिए पिंच करने और पकड़ने के लिए अपना हाथ बंद करने के लिए स्मार्ट ग्लास कैमरे का इस्तेमाल करें। गेमपैड स्टिक हिलते और मुड़ते हैं। Joy-Con पोज़िशन ट्रैकिंग की जगह लेता है। गेम के दौरान ट्रैकिंग लैग हो सकती है या खो सकती है। + ट्रैकिंग में Luma Ultra कैमरों के तहत नंगे हाथों से ऑपरेट होने वाले कंट्रोलर चालू करें। पहले खुले हाथ दिखाएं। + शेयर्ड Luma Ultra कैलिब्रेशन + शेयर्ड Luma Ultra बेस का इस्तेमाल करना। अपने स्मार्ट ग्लास की सटीकता को वेरिफ़ाई करने के लिए उन्हें खुद कैलिब्रेट करें। + मापे गए कैलिब्रेशन को वेरिफ़ाई किया गया + वैलिडेशन ज़रूरी है + मापी गई दूरी की जाँच पास होने के बाद, नंगे हाथों से ऑपरेट किए जाने वाले कंट्रोलर उपलब्ध हो जाते हैं। + ट्रैकिंग खो गई + अच्छी रोशनी वाले कमरे में धीरे-धीरे चारों ओर देखें।\nट्रैकिंग कैमरे साफ़ रखें और फ़र्नीचर या दूसरी दिखने वाली डिटेल की ओर मुँह करके रखें। + अभी भी अटके हुए हैं? आपके फ़ोन पर: स्मार्ट चश्मा → ट्रैकिंग → सेटअप खोलें → डायग्नोस्टिक्स दिखाएँ → ट्रैकिंग पुनरारंभ करें। + स्मार्ट चश्मा डिस्कनेक्ट हो गया + USB कनेक्शन की जांच करें और स्मार्ट चश्मे को फिर से कनेक्ट करें।\nयदि आपके फोन पर USB-एक्सेस प्रॉम्प्ट दिखाई दे तो उसे स्वीकार करें। + एक बार कनेक्ट होने के बाद, ट्रैकिंग बहाल करने के लिए अच्छी रोशनी वाले कमरे में धीरे-धीरे चारों ओर देखें। + फिर से केंद्रित करना ज़रूरी है + ट्रैकिंग नई जगह पर वापस आ गई है.\nआगे देखें, फिर अपने फ़ोन पर ट्रैकिंग सेंटर रीसेट करें पर टैप करें. + आप स्मार्ट ग्लास → ट्रैकिंग → ओपन सेटअप में भी ट्रैकिंग सेंटर रीसेट कर सकते हैं. आपका सेव किया गया कैमरा कैलिब्रेशन रखा जाता है. + एक पल के लिए रुकें + ट्रैकिंग सेंटर रीसेट किया जा रहा है.\nट्रैकिंग के सेटल होने तक स्मार्ट ग्लास को स्थिर रखें. + हेड ट्रैकिंग तैयार होने पर यह स्क्रीन स्वचालित रूप से बंद हो जाती है। + हाथों से स्थिर निशाना लगाना + अपने कंधे से हथेली के माध्यम से निशाना लगाओ। कलाई-नियंत्रित घुमाव के लिए बंद करें। + स्थानिक सेटअप + ट्रैकिंग की प्रतीक्षा में... + बाएँ और दाएँ ट्रैकिंग कैमरे + कैमरा सिंक्रनाइज़ेशन + तैयार + कैमरा और हेड ट्रैकिंग के लाइन में लगने की प्रतीक्षा की जा रही है। स्मार्ट ग्लास कनेक्ट रखें. + 1. अंशांकन लक्ष्य तैयार करें + वास्तविक आकार में प्रिंट करें + प्रत्येक वर्ग की माप 30 मिमी (1.181 इंच) होनी चाहिए। अच्छी रोशनी वाले क्षेत्र में एक सख्त सतह पर शीट को सपाट स्थापित करें। + कैलिब्रेशन बोर्ड प्रिंट करें + 2. विभिन्न दृश्यों को कैप्चर करें + अंशांकन लक्ष्य को स्थिर रखें + स्मार्ट चश्मे को पास, दूर और बग़ल में ले जाएँ। उन्हें बाएँ/दाएँ मोड़ें, उन्हें ऊपर/नीचे झुकाएँ और उन्हें बग़ल में झुकाएँ। दोनों कैमरों में अंशांकन लक्ष्य रखें और प्रत्येक कैप्चर से पहले थोड़ी देर रुकें। + नया अंशांकन प्रारंभ करें + कैमरा सिंक्रनाइज़ेशन की प्रतीक्षा की जा रही है। + दृश्य एकत्र करने के लिए एक नया अंशांकन प्रारंभ करें। + अंशांकन लक्ष्य को दोनों पूर्वावलोकनों में दृश्यमान रखें। विभिन्न कोणों से कम से कम 24 तीव्र दृश्य कैप्चर करें। + कैप्चरिंग... + अंशांकन लक्ष्य दृश्य कैप्चर करें + कैमरा संरेखण की गणना करें + गणना कर रहा हूं... + अंशांकन की गणना करें + 3. दूरी की जाँच करें + मापी गई दूरी + 12 इंच या 30 सेमी से शुरू करें ताकि मुद्रित मार्करों का पता लगाना आसान हो। वह सटीक माप चुनें जिसका आप उपयोग करेंगे. + बाएँ कैमरे से कैलिब्रेशन लक्ष्य के केंद्र तक की दूरी + दूरी की जाँच हो रही है... + दूरी मान्य करें + डायग्नोस्टिक्स + डायग्नोस्टिक्स दिखाएं + कैमरा टाइमिंग और ट्रैकिंग रिकवरी टूल। + कैमरा टाइमिंग + हाथों की ट्रैकिंग से इनपुट + कैमरे की टाइमिंग का इंतजार है। + कैमरा छवियाँ + हाथों की GPU पहचान + CPU डिफ़ॉल्ट है। GPU प्रायोगिक है और SteamVR को पुनः आरंभ करने का कारण बन सकता है। ट्रैकिंग पुनः प्रारंभ होने पर यह विकल्प रीसेट हो जाता है। + हाथों के मॉडलों का लाइट डिटेक्शन + हाथों पर लाइट पाम डिटेक्टर और लाइट कुंजी बिंदुओं का उपयोग करें। लक्ष्य, चुटकी और पकड़ने की सटीकता की जाँच करें। ट्रैकिंग पुनरारंभ होने पर रीसेट हो जाता है। + हाथों की ट्रैकिंग के लिए स्वचालित इनपुट आवृत्ति + इनपुट को प्रसंस्करण गति के अनुसार समायोजित करें। ट्रैकिंग पुनरारंभ होने पर रीसेट हो जाता है। + हाथों की ट्रैकिंग के लिए इनपुट आवृत्ति सीमित करें + कैमरे की आधी छवियों का उपयोग करें। अधिकतम आवृत्ति की तुलना करने के लिए बंद करें. ट्रैकिंग पुनरारंभ होने पर रीसेट हो जाता है। + डायग्नोस्टिक कैप्चर + एक स्टीरियो छवि जोड़ी को स्थानीय रूप से सहेजें। अनुरोध किए जाने पर ही छवियाँ सहेजी जाती हैं। + कैमरा छवि सहेजें + ट्रैकिंग पुनः प्रारंभ करें + यदि अच्छी रोशनी वाले क्षेत्र में ट्रैकिंग ठीक नहीं होती है तो इसका उपयोग करें। पुनरारंभ के लिए एक नए ट्रैकिंग मूल की आवश्यकता होती है। + पुनः आरंभ करें + ट्रैकिंग पुनः प्रारंभ करें? + सेव न किए गए कैलिब्रेशन व्यू खो जाएँगे. इसके बाद स्मार्ट ग्लास को स्थिर रखें और ट्रैकिंग के ठीक होने पर ट्रैकिंग सेंटर रीसेट करें. + %1$d / 24 बार देखा गया + कैप्चर रोका गया: %1$s + माप %1$s। दोनों पूर्वावलोकनों में पूर्ण अंशांकन लक्ष्य दिखाएँ, फिर स्थिर रखें। + %1$.1f हर्ट्ज़ • छवि आयु %2$.1f एमएस • प्रसंस्करण %3$.1f एमएस + कैमरा छवियों की इनपुट सीमा %1$.1f हर्ट्ज़ • %2$.0f %%। हेड ट्रैकिंग अपनी अधिकतम आवृत्ति पर जारी रहती है। + %1$d संसाधित हुआ • %2$d हटा दिया गया • %3$d इनपुट सीमा के कारण छोड़ दिया गया + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra कैलिब्रेशन + 100%/वास्तविक आकार पर प्रिंट करें। प्रत्येक वर्ग: 30 मिमी (1.181 इंच)। + अंशांकन लक्ष्य को सपाट और स्थिर रखें; कैप्चर के बीच स्मार्ट चश्मे को घुमाएँ। + स्केल जांच: टिकों के बीच 100 मिमी (3.937 इंच)। + 12 इंच (30.48 सेमी) + 30 सेमी (11.81 इंच) + 20 इंच (50.8 सेमी) + 50 सेमी (19.69 इंच) + बंद + स्थिर ट्रैकिंग की प्रतीक्षा में + डिसकनेक्ट किया गया + नंगे हाथों से संचालित होने वाले नियंत्रक बंद हैं + पोजिशनल ट्रैकिंग बंद है या स्मार्ट चश्मा डिस्कनेक्ट हो गया है + ट्रैकिंग सेंटर रीसेट करने का अनुरोध किया गया — ट्रैकिंग के स्थिर होने तक स्थिर रखें + ट्रैकिंग खो गई - दृश्यमान विवरण के साथ एक अच्छी रोशनी वाले क्षेत्र का सामना करें + ट्रैकिंग ओरिजिन बदल गया — ट्रैकिंग सेंटर रीसेट करें पर टैप करें, फिर स्थिर रखें + 6DoF सक्रिय + Luma Ultra को कनेक्ट करें और पोजिशनल ट्रैकिंग सक्षम करें। + इस कनेक्शन के लिए अंशांकन सत्यापित। + अंशांकन सत्यापित और सहेजा गया। + स्टीरियो कैमरे की प्रतीक्षा है + हाथों की ट्रैकिंग का इंतजार + 5 × 7 अंशांकन लक्ष्य को स्थिर रखें। स्मार्ट चश्मे को घुमाते और घुमाते हुए 24+ दृश्य कैप्चर करें। + अगली कैमरा छवि की प्रतीक्षा है। स्मार्ट चश्मे को स्थिर रखें। + अगली कैमरा छवि की जाँच कर रहा हूँ। पूर्ण अंशांकन लक्ष्य को दृश्यमान रखें और स्थिर रखें। + पहले अंशांकन प्रारंभ करें + कोई ताज़ा कैमरा छवि नहीं आई। स्मार्ट ग्लास कनेक्शन और कैमरा पूर्वावलोकन जांचें, फिर पुनः प्रयास करें। + कैमरा घड़ी रीसेट + ट्रैकिंग कोऑर्डिनेट सिस्टम बदल गया है. आपके व्यू रीकैलकुलेशन के लिए सेव किए गए हैं. ट्रैकिंग सेंटर रीसेट करें, फिर ज़्यादा व्यू कैप्चर करने के लिए नया सेट शुरू करें. + डिवाइस अंशांकन लोड किया गया + Luma Ultra बेस कैलिब्रेशन लोड किया गया + अंशांकन आवश्यक है + सबसे पहले स्टार्ट न्यू कैलिब्रेशन पर टैप करें। + ट्रैकिंग सेंटर रीसेट करने के लिए ट्रैकिंग के स्थिर होने का इंतज़ार किया जा रहा है. थोड़ी देर के लिए स्थिर रखें. + ट्रैकिंग बदल गई है. ट्रैकिंग सेंटर को रीसेट करने के लिए एक बार टैप करें, फिर कैप्चर करने से पहले उसे स्थिर रखें. + कैप्चर अस्वीकृत: कैप्चर के दौरान हेड ट्रैकिंग सिंक्रोनाइज़ नहीं थी या उसमें बदलाव आया। स्थिर रहें और पुनः प्रयास करें। + दूरी की जांच करने से पहले कैमरा संरेखण की गणना करें। + कैमरा प्रोसेसिंग विफल रही + हाथों का पता लगाने के दौरान हेड ट्रैकिंग बदल गई + कैमरा और हेड सिंक्रोनाइज़ेशन की प्रतीक्षा की जा रही है + किसी कलाई का पता नहीं चला। अपने Joy-Con कंट्रोलर हैंडल को स्मार्ट चश्मे के सामने रखें + कोई हाथ नहीं मिला। स्मार्ट चश्मे के सामने खुली हथेलियाँ दिखाएँ + कलाइयाँ केवल एक कैमरे में दिखाई देती हैं; अपने नियंत्रक हैंडल को साझा दृश्य में रखें + केवल एक कैमरे में हाथ दिखाई दे रहे हैं; दोनों हथेलियों को साझा दृश्य में रखें + दोनों कैमरे हाथ देखते हैं, लेकिन बाएँ/दाएँ मिलान अस्पष्ट है + हाथों का पता चला, लेकिन स्टीरियो गहराई असंगत है + कलाई की स्थिति को स्टीरियो या मोशन जांच द्वारा अस्वीकार कर दिया गया + स्टीरियो बिंदुओं का पता चला, लेकिन हथेली की ज्यामिति असंगत है + हाथों को सक्षम करने के लिए पूर्ण अंशांकन और दूरी की जांच + स्थिर हेड ट्रैकिंग की प्रतीक्षा कर रहा है; अनुरोध किए जाने पर ट्रैकिंग सेंटर को रीसेट करें + कैमरा अवलोकन बहुत पुराना है; एक नई जोड़ी का इंतजार है + फ़िट %1$.2f पीएक्स। बाएं कैमरे से अंशांकन लक्ष्य केंद्र तक अपनी चयनित दूरी को मापें, फिर सत्यापित करें। + OpenCV अनुपलब्ध: %1$s + %1$d सहेजे गए दृश्य पुनर्स्थापित किए गए। पुनः प्रयास करने के लिए अंशांकन की गणना करें, या अधिक कैप्चर करने के लिए एक नया सेट प्रारंभ करें। + कैप्चर किया गया %1$d / 24 बार देखा गया। अंशांकन लक्ष्य निश्चित रखें; अगले दृश्य के लिए स्मार्ट चश्मा हटाएँ। + कैप्चर अस्वीकृत: %1$d / दोनों कैमरों में 12 आवश्यक कोने दिखाई दे रहे हैं। अंशांकन लक्ष्य को और अधिक दिखाएं, स्थिर रखें, फिर पुनः प्रयास करें। + दूरी की जांच पूरी नहीं हो सकी: %1$s। पुनः प्रयास करें। + हाथों का पता लगाना अनुपलब्ध: %1$s। पुनः प्रयास करने के लिए CPU/GPU बदलें या नंगे हाथों से संचालित नियंत्रकों को टॉगल करें। + हाथों का पता लगाना %1$d एमएस से अधिक हो गया; अवलोकन त्याग दिया गया + %1$d / 2 Joy-Con कलाई की स्थिति स्टीरियो द्वारा मापी गई + ट्रैक की गई हथेलियाँ: %1$d / 2; पिंच के लिए तैयार: %2$d; पकड़ने के लिए तैयार: %3$d + डायग्नोस्टिक कैप्चर को %1$s में सहेजा गया + हाथों का पता लगाना बंद कर दिया गया: %1$s + स्टीरियो %1$d×%2$d; %3$s + हेड ट्रैकिंग और अंशांकन लक्ष्य %1$s (सीमा 5 सेमी/2 इंच) से असहमत हैं। अंशांकन लक्ष्य को निश्चित रखें और नया सेट शुरू करने से पहले स्थिर ट्रैकिंग की प्रतीक्षा करें। स्मार्ट चश्मे को धीरे से घुमाएँ और झुकाएँ; प्रत्येक कैप्चर से पहले रुकें। + स्थिर अंशांकन लक्ष्य के कम से कम 24 विविध दृश्य कैप्चर करें। + स्मार्ट चश्मे को बाएँ और दाएँ घुमाएँ, और उन्हें ऊपर और नीचे झुकाएँ; रोटेशन के बिना गति कैमरा संरेखण को कैलिब्रेट नहीं कर सकती। + अविश्वसनीय कैमरा बेसलाइन + अपने सिर को अधिक विविध दिशाओं में घुमाएँ। + अमान्य कैमरा-टू-हेड रोटेशन + कैमरा-टू-हेड संरेखण असंगत है। + अंशांकन समाप्त नहीं हो सका। %1$s आपके कैप्चर किए गए दृश्य सहेजे गए हैं। + हेल्ड-आउट रिप्रोजेक्शन त्रुटि %1$.2f px 2 px से अधिक है। पुन: अंशांकित करें. + %1$d / दोनों कैमरों में 24 चेकरबोर्ड कोनों का पता चला। पूर्ण अंशांकन लक्ष्य को दृश्यमान रखें और स्थिर रखें। यदि यह पहले से ही दिखाई दे रहा है, तो 12 इंच या 30 सेमी का चयन करें और पुनः प्रयास करने से पहले उस निकटतम दूरी को मापें। + अंशांकन लक्ष्य दृश्यमान है, लेकिन इसकी गहराई को विश्वसनीय रूप से नहीं मापा जा सका। स्मार्ट ग्लास को स्थिर रखें और अंशांकन लक्ष्य को सपाट और अच्छी रोशनी में रखें, फिर पुनः प्रयास करें। + कैमरे का माप अमान्य था। स्थिर रहें और पुनः प्रयास करें। + दूरी जांच पास हो गई। + बाएं कैमरे से अंशांकन लक्ष्य केंद्र तक की दूरी दोबारा जांचें, फिर पुनः प्रयास करें। + कैमरों की माप %1$s हुई; चयनित दूरी %2$s. %3$s + अंशांकन शुरू करने से पहले दोनों कैमरा पूर्वावलोकन की प्रतीक्षा करें। + सहेजे गए दृश्यों की पुनर्गणना की जा सकती है। वर्तमान ट्रैकिंग समन्वय प्रणाली में कैप्चर करने के लिए एक नया अंशांकन प्रारंभ करें। + हैंड मॉडल चेकसम बेमेल + OpenCV लोड नहीं हो सका diff --git a/app/src/main/res/values-hu/strings.xml b/app/src/main/res/values-hu/strings.xml index 65b2417b46..d60f27fa94 100644 --- a/app/src/main/res/values-hu/strings.xml +++ b/app/src/main/res/values-hu/strings.xml @@ -2366,14 +2366,14 @@ Kijelző Frissítési frekvencia 3D (egymás melletti) - Mindkét szem egy 3840×1080-as kép saját felét kapja. Ha a kép eltűnik, tartsa lenyomva a szemüveg 2D/3D gombját. + Váltsa az okosszemüveget egymás melletti 3D-re. A fejkövetés külön vezérelhető. Nem sikerült megerősíteni a 3D-jelet. Próbáld újra, ha visszatér a 2D-kép. Nincs kép: a szemüveg olyan módban van, amelyet ez a telefon nem tud küldeni. Tartsa lenyomva a 2D/3D gombját, vagy húzza ki, és dugja vissza. 3D frissítési frekvencia 3D a VR-játékokhoz 3D-re vált, amíg a SteamVR fut, utána vissza. - 3D kép - Automatikus: a SteamVR kitölti a látóteret; más játékok 3D-ben képernyőként lebegnek, 2D-ben laposak maradnak. + Kép + Az Automatikus mód lapos tartalmat jelenít meg mindkét szemben, és érzékeli a SteamVR-t. SBS tartalomhoz válassza az Egymás melletti játék lehetőséget. Automatikus Virtuális képernyő Egymás melletti 3D játék @@ -2383,20 +2383,20 @@ Ezek a beállítások akkor érvényesek, ha a Játék a szemüvegen be van kapcsolva, és a játék ott jelenik meg. Az Automatikus mód teljes képernyőn tartja ezt a 2D-s játékot. Használjon virtuális képernyőt a szélesség, a távolság és a fejkövetés beállításához. Virtuális képernyő használata - A SteamVR kitölti a látóteret. A látómezőt lent állíthatja; a szélesség és a távolság csak virtuális képernyőre vonatkozik. + A SteamVR kitölti a nézetet. Állítsa be a látómezőt VR-ben; a szélesség és a távolság csak egy virtuális képernyőre vonatkozik. Az egymás melletti 3D-s játékok mindkét szem látóterét kitöltik. A szélesség és a távolság csak virtuális képernyőre vonatkozik. Az Automatikus mód rögzítve tartja ezt a 2D-s játékot a látótérben. A fejkövetéshez válassza a Kijelző részben a Virtuális képernyő lehetőséget. A fejkövetés virtuális képernyőre vagy futó SteamVR-játékra vonatkozik. - Szemüveg + Eszköz Fényerő Hangerő Elsötétítés Elsötétíti az elülső lencséket. - Fejkövetés + Követés Fejkövetés A szemüveg saját érzékelői a fejével együtt forgatják a virtuális képernyőt és a SteamVR-t. Nézet középre igazítása - Középre + Képernyő újraközpontosítása SteamVR látómező Kisebb érték közelebb hozza a SteamVR-t és kitölti a szemüveget; nagyobb többet mutat a környezetéből. Játék ezen: %1$s @@ -2417,8 +2417,8 @@ Törli a mentett kalibrációt, és visszaállítja a modell alapértékeit? A szemüveg visszavétele után igazítsa középre a nézetet. Visszaállítás Kézkövetés - Nyomon kövesse a kamera a kezeit? - A kamera látja a kezeit. Ha nincs csatlakoztatva kontroller, a puszta kezei lesznek a VR-kezek: kattintáshoz érintse össze a hüvelyk- és mutatóujját, megragadáshoz zárja ökölbe a kezét, a menühöz pedig fordítsa maga felé a tenyerét, és érintse össze az ujjait. Joy-Conokkal oda helyezi őket, ahol a kezei valóban vannak. A képeket ez az eszköz dolgozza fel, és soha nem menti el vagy küldi el őket. + Kezek vagy Joy-Con kontrollerek követése a telefonkamerával? + Ha nincs csatlakoztatva kontroller, a telefon kamerája követi a kezeidet VR-ban: kattintáshoz csípd össze a hüvelykujjadat és a mutatóujjadat, megfogáshoz zárd össze a kezed, a menü megnyitásához pedig fordítsd magad felé a tenyeredet, majd csípd össze őket. Párosított Joy-Con kontrollerek esetén a kamera követi a pozíciójukat, miközben a Joy-Con kontrollerek forgatást és gombbevitelt biztosítanak. A képeket ezen az eszközön dolgozzák fel, és soha nem mentik vagy küldik el. Hátlapi kamera Ajánlott. Általában élesebb és szélesebb látószögű. Előlapi kamera @@ -2426,7 +2426,7 @@ Kamera használata Most nem Kézkövetés kamerával - Ha nincs csatlakoztatva kontroller, a kezei lesznek a VR-kezek: kattintáshoz érintse össze az ujjait, a menühöz tenyérrel maga felé tegye ugyanezt. Joy-Conokkal oda helyezi őket, ahol a kamera látja. A képek ezen az eszközön maradnak. + Használd a telefon kameráját puszta kézzel végzett mozdulatokhoz vagy a párosított Joy-Con kontrollerek pozicionálásához VR-ban. A Joy-Con kontrollerek forgatást és gombbemeneteket biztosítanak. Szünetel, amíg az okosszemüveg követi a kezeidet vagy a Joy-Con kontrollereket. A képek feldolgozása csak ezen az eszközön történik. Kamera Kamerahozzáférés Engedélyezze a kamerahozzáférést, hogy elindulhasson a kézkövetés. @@ -2680,4 +2680,208 @@ %1$s átalakítása a Steamhez. Hagyd nyitva a DroidDecket. Ez az eszköz nem tudja dekódolni a videót. Nem sikerült importálni a videót + Luma Ultra kamerák — Kísérleti + Joy-Con pozíciókövetés + Használd az okosszemüveg kameráit a párosított Joy-Con kontrollerek pozicionálásához. A forgatás és a gombbemenetek a Joy-Con kontrollerekről származnak. A pozíció akkor becsült, amikor a csuklód rejtve van. Helyettesíti a puszta kézzel működtetett kontrollereket, és szünetelteti a telefonkamera követést. Irányítsd a Joy-Con kontrollereket előre a követőközpont csatlakoztatásakor vagy visszaállításakor. + Először engedélyezd a pozíciókövetést. Mozgásérzékelős Joy-Con kontrollereket igényel Android 12-es vagy újabb rendszeren. Alapértelmezés szerint ki van kapcsolva. + Okosszemüveg + A kijelző és a fejkövetés beállításai megoszlanak a DroidDeck menükben, játékokban és asztali munkamenetekben. + Csatlakoztasd az okosszemüveget a kijelző és a követés beállításainak módosításához. A mentett beállítások a leválasztáskor is megmaradnak. + VR + Kijelző mód + 2D kimenet + 3D kimenet + Kép és virtuális képernyő + Pozíció és padlószint + Kezek követése — Kísérleti + Követési állapot + 2D felbontás + 3D felbontás + VR felbontás + Automatikus + Ugyanaz, mint a 2D / 3D + Kimeneti felbontás szemenként. + Engedélyezze a Játék okosszemüvegen funkciót a kijelző natív 30 Hz-es módjának kiválasztásához. + Lapos játékok rögzítése előtted, hogy körülnézhess. Engedélyezi a Játék okosszemüvegen funkciót 3D-re váltás nélkül. + A szélesség és távolság azonnal frissíti a követett virtuális képernyőt a DroidDeck menükben, játékokban és asztali munkamenetekben. + A pozíciókövetés magában foglalja a fej elforgatását a SteamVR-ben. Csak elforgatásos követéshez kapcsolja ki a pozíciókövetést. + A fej mozgását vezérli a virtuális képernyőn. A pozíciókövetés magában foglalja a fej elforgatását a SteamVR-ben. + Gyors műveletek + Nézz oda, ahová a képernyőt szeretnéd helyezni, majd állítsd vissza a követőközpontot a magasság és az irány beállításához. + Joy-Con újraközpontosítása + Telefonkamera — Kísérleti + Kezek vagy Joy-Con kontrollerek követése + Pozíciókövetés — kísérleti + Fizikai mozgás VR-ban és virtuális képernyők körül. A követés újraindítása eltart egy ideig. + Aktuális szemmagasság a padló felett + Padlószint beállítása az aktuális magasság alapján + Padlószint beállítása + Sztereó kamera beállítása és diagnosztika + Játék előtt ellenőrizze a kamera kalibrálását és a kézkövetést. + Beállítás megnyitása + Puszta kézzel működtetett kontrollerek + Használja az okosszemüveg kameráit a kezeivel való célzáshoz, csíptesse össze a kattintáshoz és zárja össze a kezét a megfogáshoz VR-ban. A gamepad botjai mozognak és forognak. Helyettesíti a Joy-Con pozíciókövetést. Játék közben késleltetheti vagy elveszítheti a követést. + Engedélyezze a puszta kézzel működtetett kontrollereket a Luma Ultra kamerák alatt a Követés módban. Először mutassa a nyitott kezeket. + Megosztott Luma Ultra kalibrálás + A megosztott Luma Ultra talp használata. Kalibrálja saját okosszemüvegét a pontosság ellenőrzéséhez. + Mért kalibráció ellenőrizve + Érvényesítés szükséges + A puszta kézzel működtetett kontrollerek a mért távolság ellenőrzésének sikeres elvégzése után válnak elérhetővé. + Elveszett a követés + Nézzen körül lassan egy jól megvilágított szobában.\nTartsa távol a követőkamerákat, és nézzen szembe a bútorokkal vagy más látható részletekkel. + Még mindig elakad? A telefonon: okosszemüveg → Követés → Beállítás megnyitása → Diagnosztika megjelenítése → Nyomon követés újraindítása. + Az intelligens szemüvegek leválasztva + Ellenőrizze az USB-kapcsolatot, és csatlakoztassa újra az okosszemüveget.\nHa megjelenik, fogadja el az USB-hozzáférési felszólítást a telefonon. + Csatlakozás után lassan nézzen körül egy jól megvilágított szobában a követés helyreállításához. + Újraközpontosítás szükséges + A követés visszatért egy új pozícióba.\nNézz előre, majd koppints a Követőközpont visszaállítása gombra a telefonodon. + A követőközpont visszaállítása funkciót az okosszemüveg → Követés → Beállítás megnyitása menüpontban is megtalálhatja. A mentett kamerakalibráció megmarad. + Maradjon mozdulatlanul egy pillanatra + A követőközpont visszaállítása folyamatban van.\nTartsa az okosszemüveget mozdulatlanul, amíg a követés beáll. + Ez a képernyő automatikusan bezárul, amikor a fejkövetés készen áll. + Stabilizált célzás kézzel + Célozzon a válláról a tenyerén keresztül. Kapcsolja ki a csuklóval vezérelt forgatáshoz. + Térbeli beállítások + Várakozás a követésre… + Bal és jobb követési kamera + Kamera szinkronizálás + Kész + Várakozás, amíg a kamera és a fejkövetés összeáll. Tartsa csatlakoztatva az okosszemüveget. + 1. Készítse elő a kalibrációs célt + Nyomtatás tényleges méretben + Minden négyzetnek 30 mm-nek (1,181 hüvelyk) kell lennie. Szerelje fel a lapot merev felületre, jól megvilágított helyen. + Kalibrációs minta nyomtatása + 2. Különböző nézetek rögzítése + Tartsa mozdulatlanul a kalibrációs célt + Vigye közelebb az intelligens szemüveget, távolabb és oldalra. Forgassa balra/jobbra, döntse fel/le, és döntse oldalra. Tartsa a kalibrációs célt mindkét kamerában, és minden rögzítés előtt álljon meg egy rövid ideig. + Indítsa el az új kalibrálást + Várakozás a kamera szinkronizálására. + Indítson el egy új kalibrálást a nézetek összegyűjtéséhez. + Tartsa láthatóan a kalibrációs célt mindkét előnézetben. Rögzítsen legalább 24 éles képet különböző szögekből. + Rögzítés… + Kalibrációs célnézet rögzítése + Számítsa ki a kamera beállítását + Számítás… + Számítsa ki a kalibrációt + 3. Ellenőrizze a távolságot + Mért távolság + Kezdje 12 hüvelykkel vagy 30 cm-rel, hogy a nyomtatott jelölők könnyebben felismerhetők legyenek. Válassza ki a használni kívánt pontos méretet. + A bal kamera és a kalibrációs céltábla középpontja közötti távolság + Távolság ellenőrzése… + Távolság érvényesítése + Diagnosztika + Diagnosztika megjelenítése + Kamera időzítési és nyomkövetési helyreállítási eszközök. + Kamera időzítése + Bemenet a kezek követéséből + Várakozás a kameraidőzítésre. + Kameraképek + A kezek GPU-felismerése + A CPU az alapértelmezett. A GPU kísérleti jellegű, és a SteamVR újraindítását okozhatja. Ez a választás visszaáll a követés újraindításakor. + Kézmodellek egyszerű észlelése + Használja a Lite tenyérérzékelőt és a Lite kulcspontokat a kezeken. Ellenőrizze a célzás, a szorítás és a megfogás pontosságát. Visszaállítja a követés újraindulásakor. + Automatikus bemeneti frekvencia a kezek nyomon követéséhez + Állítsa be a bemenetet a feldolgozási sebességhez. Visszaállítja a követés újraindulásakor. + Korlátozza a bemeneti frekvenciát a kezek követéséhez + A kameraképek felét használja. A maximális frekvencia összehasonlításához kapcsolja ki. Visszaállítja a követés újraindulásakor. + Diagnosztikai rögzítés + Mentse el egy sztereó képpárt helyileg. A képek csak kérésre kerülnek mentésre. + Kamerakép mentése + Indítsa újra a követést + Akkor használja, ha a követés nem áll helyre jól megvilágított területen. Az újraindításhoz új nyomkövetési eredetre van szükség. + Indítsa újra + Újraindítja a követést? + A nem mentett kalibrációs nézetek elvesznek. Tartsa mozdulatlanul az okosszemüveget, és állítsa vissza a követőközpontot, amikor a követés helyreállt. + %1$d / 24 megtekintés + A rögzítés szünetel: %1$s + %1$s. intézkedés. Jelenítse meg a teljes kalibrációs célt mindkét előnézetben, majd tartsa mozdulatlanul. + %1$.1f Hz • kép kora %2$.1f ms • feldolgozás %3$.1f ms + Bemeneti korlát %1$.1f Hz • %2$.0f%% kamerakép. A fejkövetés a maximális frekvencián folytatódik. + %1$d feldolgozva • %2$d elvetve • %3$d kihagyva a beviteli korlát miatt + DroidDeck ChArUco 30 mm + DroidDeck – Luma Ultra kalibrálás + Nyomtatás 100%/Tényleges méretben. Mindegyik négyzet: 30 mm (1,181 hüvelyk). + Tartsa a kalibrációs célt síkban és álló helyzetben; mozgassa az okosszemüveget a felvételek között. + Skálaellenőrzés: 100 mm (3,937 hüvelyk) a jelölések között + 12 hüvelyk (30,48 cm) + 30 cm (11,81 hüvelyk) + 20 hüvelyk (50,8 cm) + 50 cm (19,69 hüvelyk) + Letiltva + Várakozás a stabil követésre + Lekapcsolva + A puszta kézzel működtetett vezérlők ki vannak kapcsolva + A helyzetkövetés ki van kapcsolva, vagy az intelligens szemüvegek le vannak választva + Követőközpont visszaállítása kérve – tartsa mozdulatlanul, amíg a követés stabilizálódik. + A követés elveszett – nézzen szembe egy jól megvilágított területtel, látható részletekkel + A követés kezdőpontja megváltozott – koppintson a követőközpont visszaállítására, majd tartsa mozdulatlanul. + 6DoF aktív + Csatlakoztassa a Luma Ultra-t és engedélyezze a helyzetkövetést. + Ehhez a kapcsolathoz a kalibráció ellenőrizve. + A kalibráció ellenőrizve és mentve. + Várakozás a sztereó kamerákra + Várakozás a kezek nyomon követésére + Tartsa mozdulatlanul az 5 × 7 kalibrációs célt. Rögzítsen 24+ nézetet az okosszemüveg mozgatása és forgatása közben. + Várakozás a következő kameraképre. Tartsa mozdulatlanul az okosszemüveget. + A következő kamerakép ellenőrzése. Tartsa láthatóan a teljes kalibrációs célt, és tartsa mozdulatlanul. + Először indítsa el a kalibrálást + Nem érkezett friss kamerakép. Ellenőrizze az okosszemüveg csatlakozását és a kamera előnézetét, majd próbálkozzon újra. + A kamera órájának visszaállítása + A követési koordinátarendszer megváltozott. A nézetek mentésre kerültek az újraszámításhoz. Állítsa vissza a követőközpontot, majd indítson új sorozatot további nézetek rögzítéséhez. + eszközkalibráció betöltve + A Luma Ultra alapkalibráció betöltve + kalibrálás szükséges + Érintse meg az Új kalibrálás indítása elemet először. + A követőközpont visszaállítása funkció stabil követést vár. Tartsa mozdulatlanul egy pillanatig. + A követés megváltozott. Koppintson egyszer a követőközpont visszaállítására, majd tartsa mozdulatlanul a rögzítés előtt. + Rögzítés elutasítva: a fejkövetés nem lett szinkronizálva vagy módosult a rögzítés során. Maradjon nyugton, és próbálja újra. + Számítsa ki a kamera beállítását a távolság ellenőrzése előtt. + A kamera feldolgozása nem sikerült + A fejkövetés megváltozott a kezek észlelése során + Várakozás a kamera és a fej szinkronizálására + Nem észleltek csuklót. Tartsa a Joy-Con kontroller fogantyúit az okosszemüveg előtt + Nem észleltek kezet. Mutasson nyitott tenyeret az okosszemüveg előtt + A csukló csak egy kamerában látható; tartsa a vezérlő fogantyúit a megosztott nézetben + A kezek csak egy kamerában láthatók; tartsa mindkét tenyerét megosztott nézetben + Mindkét kamera látja a kezeket, de a bal/jobb párosítás kétértelmű + Kezek észlelve, de a sztereó mélység nem következetes + Sztereó vagy mozgásellenőrzések által elutasított csuklóhelyzet + Sztereópontok észlelve, de a tenyér geometriája inkonzisztens + Végezze el a kalibrálást és a távolságellenőrzést a kezek engedélyezéséhez + Várakozás stabil fejkövetésre; szükség esetén állítsa vissza a követőközpontot. + A kamerás megfigyelés túl régi; friss párra vár + Fit %1$.2f px. Mérje meg a kiválasztott távolságot a bal oldali kamera és a kalibrációs célközép között, majd érvényesítse. + Az OpenCV nem érhető el: %1$s + %1$d mentett nézet visszaállítva. Számítsa ki a kalibrációt az újrapróbálkozáshoz, vagy indítson új sorozatot, hogy többet rögzítsen. + Rögzített %1$d / 24 megtekintés. Tartsa rögzítve a kalibrációs célt; mozgassa az okosszemüveget a következő nézethez. + Rögzítés elutasítva: %1$d / 12 szükséges sarok mindkét kamerán látható. Mutasson többet a kalibrációs célból, tartsa mozdulatlanul, majd próbálja újra. + A távolságellenőrzést nem sikerült befejezni: %1$s. Próbáld újra. + A kezek észlelése nem érhető el: %1$s. Az újrapróbálkozáshoz cserélje ki a CPU/GPU-t, vagy váltson puszta kézzel működtetett vezérlőket. + A kezek észlelése meghaladja a %1$d ms-ot; a megfigyelést elvetették + %1$d / 2 Joy-Con csuklópozíció sztereóval mérve + Követett tenyerek: %1$d / 2; csippentésre kész: %2$d; megfogásra kész: %3$d + Diagnosztikai rögzítés mentve ide: %1$s + Leállított kezek követése: %1$s + Sztereó %1$d×%2$d; %3$s + A fejkövetés és a kalibrálási cél %1$s-kal (korlátozás: 5 cm) nem egyezik. Tartsa rögzítve a kalibrációs célt, és várja meg a folyamatos követést, mielőtt új sorozatot kezdene. Finoman fordítsa és döntse meg az intelligens szemüveget; szünetet minden rögzítés előtt. + Rögzítsen legalább 24 különböző nézetet az álló kalibrációs célpontról. + Forgassa balra és jobbra az intelligens szemüveget, majd döntse fel és le; a forgatás nélküli mozgás nem tudja kalibrálni a kamera beállítását. + Valószínűtlen kamera alapvonal + Mozgassa fejét változatosabb tájolásokon. + Érvénytelen kamera-fej elforgatás + A kamera-fej igazítás nem következetes. + A kalibrálást nem sikerült befejezni. %1$s A rögzített nézetek mentésre kerülnek. + Kitartott újravetítési hiba %1$.2f px meghaladja a 2 képpontot. Újrakalibrálás. + %1$d / 24 sakktábla-sarkot észleltünk mindkét kamerában. Tartsa láthatóan a teljes kalibrációs célt, és tartsa mozdulatlanul. Ha már látható, válassza ki a 12 hüvelyk vagy a 30 cm-t, és mérje meg a közelebbi távolságot, mielőtt újra próbálkozna. + A kalibrációs cél látható, de a mélysége nem mérhető megbízhatóan. Tartsa mozdulatlanul az intelligens szemüveget, és tartsa a kalibrációs célt síkban és jól megvilágítva, majd próbálkozzon újra. + A kamera mérése érvénytelen volt. Maradjon nyugton, és próbálja újra. + A távolság ellenőrzése sikeres. + Ellenőrizze újra a bal oldali kamera és a kalibrációs célpont közötti távolságot, majd próbálkozzon újra. + Mért kamerák: %1$s; kiválasztott távolság %2$s. %3$s + A kalibrálás megkezdése előtt várja meg mindkét kamera előnézetét. + Az elmentett nézetek újraszámíthatók. Indítson el egy új kalibrálást, hogy rögzítse az aktuális követési koordináta-rendszerben. + A kézi modell ellenőrzőösszegének eltérése + Az OpenCV betöltése nem sikerült + 3DoF virtuális képernyő + 6DoF virtuális képernyő diff --git a/app/src/main/res/values-in/strings.xml b/app/src/main/res/values-in/strings.xml index 1d40fa1930..8aee58b539 100644 --- a/app/src/main/res/values-in/strings.xml +++ b/app/src/main/res/values-in/strings.xml @@ -2341,14 +2341,14 @@ Tampilan Refresh rate 3D (berdampingan) - Setiap mata mendapat separuhnya sendiri dari gambar 3840×1080. Jika gambar hilang, tahan tombol 2D/3D kacamata. + Alihkan kacamata pintar ke 3D berdampingan. Pelacakan kepala dikontrol secara terpisah. Sinyal 3D belum terkonfirmasi. Coba lagi setelah gambar 2D kembali. Tidak ada gambar: kacamata dalam mode yang tidak bisa dikirim ponsel ini. Tahan tombol 2D/3D-nya, atau cabut lalu colokkan lagi. Refresh rate 3D 3D untuk game VR Beralih ke 3D saat SteamVR berjalan, lalu kembali setelahnya. - Gambar 3D - Otomatis: SteamVR memenuhi pandangan; game lain melayang sebagai layar di 3D dan tetap datar di 2D. + Gambar + Otomatis menampilkan konten datar di kedua mata dan mendeteksi SteamVR. Pilih game berdampingan untuk konten SBS. Otomatis Layar virtual Game 3D berdampingan @@ -2358,20 +2358,20 @@ Setelan ini berlaku saat Game di kacamata aktif dan game ditampilkan di sana. Otomatis menjaga game 2D ini tetap layar penuh. Gunakan layar virtual untuk mengatur lebar, jarak, dan pelacakan kepalanya. Gunakan layar virtual - SteamVR memenuhi pandangan. Atur bidang pandangnya di bawah; lebar dan jarak hanya berlaku untuk layar virtual. + SteamVR memenuhi tampilan. Sesuaikan bidang pandangnya di VR; lebar dan jarak hanya berlaku untuk layar virtual. Game berdampingan memenuhi pandangan setiap mata. Lebar dan jarak hanya berlaku untuk layar virtual. Otomatis menjaga game 2D ini tetap diam dalam pandangan. Pilih Layar virtual di Tampilan untuk menggunakan pelacakan kepala. Pelacakan kepala berlaku untuk layar virtual atau game SteamVR yang sedang berjalan. - Kacamata + Perangkat Kecerahan Volume Peredup lensa Menggelapkan lensa depan. - Pelacakan kepala + Pelacakan Pelacakan kepala Sensor milik kacamata memutar layar virtual dan SteamVR mengikuti kepala Anda. Posisikan ulang tampilan - Posisikan ulang + Pusatkan ulang layar Bidang pandang SteamVR Lebih rendah membawa SteamVR lebih dekat dan memenuhi kacamata; lebih tinggi menampilkan lebih banyak di sekitar Anda. Bermain di %1$s @@ -2392,8 +2392,8 @@ Hapus kalibrasi tersimpan dan pulihkan default model? Posisikan ulang tampilan setelah memakai kacamata kembali. Reset Pelacakan tangan - Lacak tangan Anda dengan kamera? - Kamera dapat melihat tangan Anda. Tanpa pengontrol yang terhubung, tangan kosong Anda menjadi tangan VR: satukan ibu jari dan telunjuk untuk mengeklik, kepalkan tangan untuk menggenggam, dan hadapkan telapak tangan ke arah Anda lalu satukan jari untuk membuka menu. Dengan Joy-Con, kamera menempatkannya di posisi tangan Anda yang sebenarnya. Gambar diproses di perangkat ini dan tidak pernah disimpan atau dikirim. + Lacak tangan atau pengontrol Joy-Con dengan kamera ponsel? + Tanpa pengontrol yang terhubung, kamera ponsel melacak tangan Anda di VR: jepit ibu jari dan jari telunjuk untuk mengklik, tutup tangan untuk meraih, dan putar telapak tangan ke arah Anda dan jepit untuk membuka menu. Dengan pengontrol Joy-Con yang terpasang, kamera melacak posisinya sementara pengontrol Joy-Con menyediakan input rotasi dan tombol. Gambar diproses di perangkat ini dan tidak pernah disimpan atau dikirim. Kamera belakang Direkomendasikan. Biasanya lebih tajam dan lebih lebar. Kamera depan @@ -2401,7 +2401,7 @@ Gunakan kamera Nanti saja Pelacakan tangan dengan kamera - Tanpa pengontrol yang terhubung, tangan Anda menjadi tangan VR: satukan jari untuk mengeklik, hadapkan telapak tangan ke arah Anda dan satukan jari untuk menu. Dengan Joy-Con, kamera menempatkannya di posisi yang dilihatnya. Gambar tetap di perangkat ini. + Gunakan kamera ponsel untuk gerakan tangan kosong atau untuk memposisikan pengontrol Joy-Con yang terpasang di VR. Pengontrol Joy-Con menyediakan rotasi dan input tombol. Berhenti sementara kacamata pintar melacak tangan atau pengontrol Joy-Con Anda. Gambar hanya diproses pada perangkat ini. Kamera Akses kamera Izinkan akses kamera agar pelacakan tangan bisa dimulai. @@ -2655,4 +2655,208 @@ Mengonversi %1$s untuk Steam. Biarkan DroidDeck tetap terbuka. Perangkat ini tidak dapat mendekode video itu. Tidak dapat mengimpor video itu + Kamera Luma Ultra — Eksperimental + Pelacakan posisi Joy-Con + Gunakan kamera kacamata pintar untuk memposisikan pengontrol Joy-Con yang terpasang. Rotasi dan input tombol berasal dari pengontrol Joy-Con. Posisi diperkirakan saat pergelangan tangan Anda tersembunyi. Menggantikan pengontrol yang dioperasikan dengan tangan kosong dan menghentikan pelacakan kamera ponsel. Arahkan pengontrol Joy-Con ke depan saat menghubungkan atau mengatur ulang pusat pelacakan. + Aktifkan pelacakan posisi terlebih dahulu. Membutuhkan pengontrol Joy-Con yang mampu mendeteksi gerakan pada Android 12 atau yang lebih baru. Nonaktif secara default. + Kacamata pintar + Pengaturan tampilan dan pelacakan kepala dibagikan di seluruh menu DroidDeck, game, dan sesi desktop. + Hubungkan kacamata pintar untuk mengubah pengaturan tampilan dan pelacakannya. Pengaturan yang Anda simpan akan tetap ada saat Anda memutuskan sambungan. + VR + Mode tampilan + Output 2D + Output 3D + Gambar dan layar virtual + Posisi dan level lantai + Pelacakan tangan — Eksperimental + Status pelacakan + Resolusi 2D + Resolusi 3D + Resolusi VR + Otomatis + Sama seperti 2D / 3D + Resolusi output per mata. + Aktifkan Game pada kacamata pintar untuk memilih mode 30 Hz asli layar. + Layar virtual 3DoF + Pasang game datar di depan Anda sehingga Anda dapat melihat sekeliling. Mengaktifkan Game pada kacamata pintar tanpa beralih ke 3D. + Lebar dan jarak memperbarui layar virtual yang dilacak untuk menu DroidDeck, game, dan sesi desktop secara instan. + Pelacakan posisi mencakup rotasi kepala di SteamVR. Untuk pelacakan hanya rotasi, matikan pelacakan posisi. + Mengontrol pergerakan kepala di layar virtual. Pelacakan posisi mencakup rotasi kepala di SteamVR. + Tindakan cepat + Lihat ke arah yang Anda inginkan untuk layar, lalu atur ulang pusat pelacakan untuk mengatur ketinggian dan arahnya. + Pusatkan ulang Joy-Con + Kamera Ponsel — Eksperimental + Lacak tangan atau pengontrol Joy-Con + Layar virtual 6DoF + Pelacakan posisi — eksperimental + Pergerakan fisik di VR dan di sekitar layar virtual. Memulai ulang pelacakan membutuhkan waktu sejenak. + Tinggi mata saat ini di atas lantai + Atur level lantai dari tinggi saat ini + Atur level lantai + Pengaturan dan diagnostik kamera stereo + Periksa kalibrasi kamera dan pelacakan tangan sebelum bermain. + Buka pengaturan + Pengontrol dioperasikan dengan tangan kosong + Gunakan kamera kacamata pintar untuk membidik dengan tangan Anda, cubit untuk mengklik dan tutup tangan Anda untuk meraih di VR. Stik gamepad bergerak dan berputar. Menggantikan pelacakan posisi Joy-Con. Mungkin mengalami lag atau kehilangan pelacakan selama permainan. + Aktifkan pengontrol yang dioperasikan dengan tangan kosong di bawah kamera Luma Ultra di Pelacakan. Tunjukkan tangan terbuka terlebih dahulu. + Kalibrasi Luma Ultra bersama + Menggunakan basis Luma Ultra bersama. Kalibrasi kacamata pintar Anda sendiri untuk memverifikasi keakuratannya. + Kalibrasi terukur terverifikasi + Validasi diperlukan + Pengontrol yang dioperasikan dengan tangan kosong tersedia setelah pemeriksaan jarak terukur berhasil. + Pelacakan hilang + Lihat sekeliling perlahan di ruangan yang terang.\nJaga agar kamera pelacak tetap bersih dan menghadap ke furnitur atau detail lain yang terlihat. + Masih buntu? Di ponsel Anda: kacamata pintar → Pelacakan → Buka pengaturan → Tampilkan diagnostik → Mulai ulang pelacakan. + Kacamata pintar terputus + Periksa sambungan USB dan sambungkan kembali kacamata pintar.\nTerima perintah akses USB di ponsel Anda jika muncul. + Setelah terhubung, lihat sekeliling secara perlahan di ruangan yang cukup terang untuk memulihkan pelacakan. + Perlu pemusatan ulang + Pelacakan telah kembali ke posisi baru.\nLihat ke depan, lalu ketuk atur ulang pusat pelacakan di ponsel Anda. + Anda juga dapat menemukan reset pusat pelacakan di kacamata pintar → Pelacakan → Buka pengaturan. Kalibrasi kamera yang Anda simpan akan tetap tersimpan. + Diam sejenak + Reset pusat pelacakan sedang berlangsung.\nJaga agar kacamata pintar tetap stabil saat pelacakan stabil. + Layar ini tertutup secara otomatis ketika pelacakan kepala sudah siap. + Membidik dengan tangan dengan stabil + Bidik dari bahumu hingga telapak tanganmu. Matikan untuk rotasi yang dikontrol pergelangan tangan. + Pengaturan spasial + Menunggu pelacakan… + Kamera pelacak kiri dan kanan + Sinkronisasi kamera + Siap + Menunggu kamera dan pelacakan kepala berbaris. Jaga agar kacamata pintar tetap terhubung. + 1. Siapkan target kalibrasi + Cetak dengan ukuran sebenarnya + Setiap persegi harus berukuran 30 mm (1,181 in). Pasang lembaran secara mendatar pada permukaan yang kaku di area yang cukup terang. + Cetak pola kalibrasi + 2. Menangkap tampilan berbeda + Jaga agar target kalibrasi tetap diam + Pindahkan kacamata pintar lebih dekat, lebih jauh dan ke samping. Putar ke kiri/kanan, miringkan ke atas/bawah, dan miringkan ke samping. Simpan target kalibrasi di kedua kamera dan jeda sebentar sebelum setiap pengambilan. + Mulai kalibrasi baru + Menunggu sinkronisasi kamera. + Mulai kalibrasi baru untuk mengumpulkan tampilan. + Jaga agar target kalibrasi tetap terlihat di kedua pratinjau. Tangkap setidaknya 24 tampilan tajam dari berbagai sudut. + Menangkap… + Menangkap tampilan target kalibrasi + Hitung penyelarasan kamera + Menghitung… + Hitung kalibrasi + 3. Periksa jaraknya + Jarak terukur + Mulailah dengan 12 inci atau 30 cm agar penanda yang dicetak lebih mudah dideteksi. Pilih pengukuran tepat yang akan Anda gunakan. + Kamera kiri ke pusat target kalibrasi + Memeriksa jarak… + Validasi jarak + Diagnostik + Tampilkan diagnostik + Alat pemulihan pengaturan waktu dan pelacakan kamera. + Pengaturan waktu kamera + Masukan dari pelacakan tangan + Menunggu timing kamera. + Gambar kamera + Deteksi GPU pada tangan + CPU adalah defaultnya. GPU bersifat eksperimental dan dapat menyebabkan SteamVR dimulai ulang. Pilihan ini disetel ulang saat pelacakan dimulai ulang. + Deteksi ringan model tangan + Gunakan detektor telapak tangan Lite dan titik kunci Lite di tangan. Periksa akurasi membidik, mencubit, dan meraih. Direset saat pelacakan dimulai ulang. + Frekuensi input otomatis untuk pelacakan tangan + Sesuaikan input dengan kecepatan pemrosesan. Direset saat pelacakan dimulai ulang. + Batasi frekuensi input untuk pelacakan tangan + Gunakan separuh gambar kamera. Matikan untuk membandingkan frekuensi maksimum. Direset saat pelacakan dimulai ulang. + Pengambilan diagnostik + Simpan satu pasangan gambar stereo secara lokal. Gambar disimpan hanya jika diminta. + Simpan gambar kamera + Mulai ulang pelacakan + Gunakan jika pelacakan tidak pulih di area yang cukup terang. Memulai ulang memerlukan asal pelacakan baru. + Mulai ulang + Mulai ulang pelacakan? + Tampilan kalibrasi yang belum disimpan akan hilang. Jaga agar kacamata pintar tetap diam setelahnya dan reset pusat pelacakan saat pelacakan dipulihkan. + %1$d / 24 tayangan diambil + Pengambilan dijeda: %1$s + Ukur %1$s. Tampilkan target kalibrasi lengkap di kedua pratinjau, lalu tahan. + %1$.1f Hz • umur gambar %2$.1f ms • pemrosesan %3$.1f ms + Batas input %1$.1f Hz • %2$.0f%% gambar kamera. Pelacakan kepala berlanjut pada frekuensi maksimumnya. + %1$d diproses • %2$d dihilangkan • %3$d dilewati berdasarkan batas masukan + DroidDeck ChArUco 30 mm + DroidDeck - Kalibrasi Luma Ultra + Cetak pada ukuran 100% / Ukuran sebenarnya. Setiap kotak: 30 mm (1,181 in). + Jaga agar target kalibrasi tetap datar dan tidak bergerak; pindahkan kacamata pintar di antara pengambilan. + Pemeriksaan skala: 100 mm (3,937 in) di antara tick + 12 inci (30,48 cm) + 30 cm (11,81 inci) + 20 inci (50,8 cm) + 50 cm (19,69 inci) + Dinonaktifkan + Menunggu pelacakan stabil + Terputus + Pengendali yang dioperasikan dengan tangan kosong dimatikan + Pelacakan posisi tidak aktif atau kacamata pintar dilepas + Reset pusat pelacakan diminta — diamkan saat pelacakan stabil + Pelacakan hilang — hadapi area yang cukup terang dengan detail yang terlihat + Asal pelacakan berubah — ketuk reset pusat pelacakan, lalu diamkan + 6DoF aktif + Hubungkan Luma Ultra dan aktifkan pelacakan posisi. + Kalibrasi diverifikasi untuk koneksi ini. + Kalibrasi diverifikasi dan disimpan. + Menunggu kamera stereo + Menunggu pelacakan tangan + Jaga agar target kalibrasi 5 × 7 tidak bergerak. Tangkap 24+ tampilan sambil menggerakkan dan memutar kacamata pintar. + Menunggu gambar kamera selanjutnya. Pegang kacamata pintar dengan tenang. + Memeriksa gambar kamera selanjutnya. Jaga agar target kalibrasi penuh tetap terlihat dan diam. + Mulai kalibrasi terlebih dahulu + Tidak ada gambar kamera baru yang tiba. Periksa sambungan kacamata pintar dan pratinjau kamera, lalu coba lagi. + Reset jam kamera + Sistem koordinat pelacakan berubah. Tampilan Anda disimpan untuk perhitungan ulang. Reset pusat pelacakan, lalu mulai set baru untuk menangkap lebih banyak tampilan. + kalibrasi perangkat dimuat + Kalibrasi dasar Luma Ultra dimuat + kalibrasi diperlukan + Ketuk Mulai kalibrasi baru terlebih dahulu. + Reset pusat pelacakan sedang menunggu pelacakan stabil. Diamkan sebentar. + Pelacakan berubah. Ketuk reset pusat pelacakan sekali, lalu diamkan sebelum menangkap. + Pengambilan ditolak: pelacakan kepala tidak sinkron atau berubah selama pengambilan. Tetap diam dan coba lagi. + Hitung keselarasan kamera sebelum memeriksa jarak. + pemrosesan kamera gagal + Pelacakan kepala berubah selama deteksi tangan + Menunggu sinkronisasi kamera dan kepala + Tidak ada pergelangan tangan yang terdeteksi. Letakkan pegangan pengontrol Joy-Con Anda di depan kacamata pintar + Tidak ada tangan yang terdeteksi. Tunjukkan telapak tangan terbuka di depan kacamata pintar + Pergelangan tangan hanya terlihat di satu kamera; pertahankan pegangan pengontrol Anda dalam tampilan bersama + Tangan hanya terlihat di satu kamera; jaga kedua telapak tangan dalam pandangan bersama + Kedua kamera melihat tangan, tetapi pencocokan kiri/kanan tidak jelas + Tangan terdeteksi, tetapi kedalaman stereo tidak konsisten + Posisi pergelangan tangan ditolak dengan pemeriksaan stereo atau gerakan + Titik stereo terdeteksi, tetapi geometri telapak tangan tidak konsisten + Kalibrasi lengkap dan pemeriksaan jarak untuk mengaktifkan tangan + Menunggu pelacakan kepala yang stabil; reset pusat pelacakan jika diminta + Pengamatan kamera terlalu tua; menunggu pasangan baru + Cocok dengan %1$.2f piksel. Ukur jarak yang Anda pilih dari kamera kiri ke pusat target kalibrasi, lalu validasi. + OpenCV tidak tersedia: %1$s + %1$d tampilan tersimpan dipulihkan. Hitung kalibrasi untuk mencoba ulang, atau mulai rangkaian baru untuk menangkap lebih banyak. + Diambil %1$d / 24 penayangan. Jaga agar target kalibrasi tetap; pindahkan kacamata pintar untuk tampilan selanjutnya. + Pengambilan gambar ditolak: %1$d / 12 sudut yang diperlukan terlihat di kedua kamera. Tampilkan lebih banyak target kalibrasi, diamkan, lalu coba lagi. + Pemeriksaan jarak tidak dapat diselesaikan: %1$s. Coba lagi. + Deteksi tangan tidak tersedia: %1$s. Ubah CPU/GPU atau pengontrol sakelar yang dioperasikan dengan tangan kosong untuk mencoba lagi. + Deteksi tangan melebihi %1$d ms; observasi dibuang + %1$d / 2 posisi pergelangan tangan Joy-Con diukur dengan stereo + Telapak tangan terlacak: %1$d / 2; gestur cubit siap: %2$d; gestur genggam siap: %3$d + Pengambilan diagnostik tersimpan ke %1$s + Pelacakan tangan dihentikan: %1$s + Stereo %1$d×%2$d; %3$s + Pelacakan kepala dan target kalibrasi berbeda sebesar %1$s (batas 5 cm / 2 inci). Pertahankan target kalibrasi tetap dan tunggu pelacakan stabil sebelum memulai set baru. Putar dan miringkan kacamata pintar dengan lembut; jeda sebelum setiap pengambilan. + Menangkap setidaknya 24 tampilan bervariasi dari target kalibrasi stasioner. + Putar kacamata pintar ke kiri dan ke kanan, lalu miringkan ke atas dan ke bawah; gerakan tanpa rotasi tidak dapat mengkalibrasi kesejajaran kamera. + Garis dasar kamera yang tidak masuk akal + Gerakkan kepala Anda ke arah yang lebih bervariasi. + Rotasi kamera-ke-kepala tidak valid + Penyelarasan kamera-ke-kepala tidak konsisten. + Kalibrasi tidak dapat diselesaikan. %1$s Tampilan yang Anda ambil disimpan. + Kesalahan proyeksi ulang yang tertunda %1$.2f px melebihi 2 px. Kalibrasi ulang. + %1$d / 24 sudut kotak-kotak terdeteksi di kedua kamera. Jaga agar target kalibrasi penuh tetap terlihat dan diam. Jika sudah terlihat, pilih 12 inci atau 30 cm dan ukur jarak terdekatnya sebelum mencoba lagi. + Target kalibrasi terlihat, namun kedalamannya tidak dapat diukur dengan andal. Pegang kacamata pintar dengan tenang dan jaga target kalibrasi tetap datar dan terang, lalu coba lagi. + Pengukuran kamera tidak valid. Tahan dan coba lagi. + Pemeriksaan jarak berhasil. + Periksa kembali jarak dari kamera kiri ke pusat target kalibrasi, lalu coba lagi. + Kamera diukur %1$s; jarak yang dipilih %2$s. %3$s + Tunggu pratinjau kedua kamera sebelum memulai kalibrasi. + Tampilan yang disimpan dapat dihitung ulang. Mulai kalibrasi baru untuk menangkap sistem koordinat pelacakan saat ini. + Ketidakcocokan checksum model tangan + OpenCV tidak dapat memuat diff --git a/app/src/main/res/values-it/strings.xml b/app/src/main/res/values-it/strings.xml index e46e4c31ae..84fc8340c8 100644 --- a/app/src/main/res/values-it/strings.xml +++ b/app/src/main/res/values-it/strings.xml @@ -2377,14 +2377,14 @@ Schermo Frequenza di aggiornamento 3D (affiancato) - Ogni occhio riceve la propria metà di un\'immagine 3840×1080. Se l\'immagine scompare, tieni premuto il pulsante 2D/3D degli occhiali. + Passa gli occhiali intelligenti alla modalità 3D side-by-side. Il tracciamento della testa è controllato separatamente. Il segnale 3D non è stato confermato. Riprova quando torna l\'immagine 2D. Nessuna immagine: gli occhiali sono in una modalità che questo telefono non può inviare. Tieni premuto il loro pulsante 2D/3D, oppure scollegali e ricollegali. Frequenza di aggiornamento 3D 3D per i giochi VR Passa al 3D mentre SteamVR è in esecuzione, poi torna indietro. - Immagine 3D - Automatico: SteamVR riempie la vista; gli altri giochi appaiono come uno schermo sospeso in 3D e restano piatti in 2D. + Immagine + La ​​modalità automatica mostra contenuti piatti in entrambi gli occhi e rileva SteamVR. Scegli Gioco Side-by-Side per contenuti SBS. Automatico Schermo virtuale Gioco affiancato @@ -2394,20 +2394,20 @@ Queste impostazioni si applicano quando Gioco sugli occhiali è attivo e il gioco è mostrato sugli occhiali. Con Automatico questo gioco 2D resta a schermo intero. Usa uno schermo virtuale per regolarne larghezza, distanza e tracciamento della testa. Usa schermo virtuale - SteamVR riempie la vista. Regola qui sotto il suo campo visivo; larghezza e distanza si applicano solo a uno schermo virtuale. + SteamVR riempie la visuale. Regola il campo visivo in VR; larghezza e distanza si applicano solo allo schermo virtuale. I giochi affiancati riempiono ciascun occhio. Larghezza e distanza si applicano solo a uno schermo virtuale. Con Automatico questo gioco 2D resta fisso nella vista. Scegli Schermo virtuale nella sezione Schermo per usare il tracciamento della testa. Il tracciamento della testa si applica a uno schermo virtuale o a un gioco SteamVR in esecuzione. - Occhiali + Dispositivo Luminosità Volume Oscuramento Scurisce le lenti frontali. - Tracciamento della testa + Tracciamento Tracciamento della testa I sensori degli occhiali ruotano lo schermo virtuale e SteamVR insieme alla tua testa. Ricentra vista - Ricentra + Ricentra lo schermo Campo visivo di SteamVR Più basso avvicina SteamVR e riempie gli occhiali; più alto mostra di più intorno a te. Gioco in corso su %1$s @@ -2428,8 +2428,8 @@ Rimuovere la calibrazione salvata e ripristinare i valori predefiniti del modello? Ricentra dopo aver rimesso gli occhiali. Ripristina Tracciamento delle mani - Tracciare le mani con la fotocamera? - La fotocamera vede le tue mani. Senza controller collegati, le tue mani nude diventano le mani VR: unisci pollice e indice per fare clic, chiudi la mano per afferrare e, per aprire il menu, gira il palmo verso di te e unisci le dita. Con i Joy-Con, li posiziona dove si trovano davvero le tue mani. Le immagini vengono elaborate su questo dispositivo e non vengono mai salvate né inviate. + Tracciare le mani o i controller Joy-Con con la fotocamera del telefono? + Senza controller collegato, la fotocamera del telefono traccia le tue mani nude in VR: pizzica il pollice e l\'indice per cliccare, chiudi la mano per afferrare e ruota il palmo verso di te e pizzica per aprire il menu. Con i controller Joy-Con abbinati, la fotocamera ne traccia la posizione mentre i controller Joy-Con forniscono input di rotazione e pulsanti. Le immagini vengono elaborate su questo dispositivo e non vengono mai salvate o inviate. Fotocamera posteriore Consigliata. Di solito più nitida e ampia. Fotocamera anteriore @@ -2437,7 +2437,7 @@ Usa la fotocamera Non ora Tracciamento mani con fotocamera - Senza controller collegati, le tue mani diventano le mani VR: unisci le dita per fare clic, palmo verso di te e dita unite per il menu. Con i Joy-Con, li posiziona dove li vede la fotocamera. Le immagini restano su questo dispositivo. + Utilizza la fotocamera del telefono per i gesti a mani nude o per posizionare i controller Joy-Con associati in VR. I controller Joy-Con forniscono la rotazione e gli input dei pulsanti. Mette in pausa mentre gli occhiali smart tracciano le tue mani o i controller Joy-Con. Le immagini vengono elaborate solo su questo dispositivo. Fotocamera Accesso alla fotocamera Consenti l\'accesso alla fotocamera per avviare il tracciamento delle mani. @@ -2705,4 +2705,208 @@ Conversione di %1$s per Steam. Tieni aperto DroidDeck. Questo dispositivo non può decodificare il video. Impossibile importare il video + Fotocamere Luma Ultra — Sperimentale + Tracciamento della posizione dei Joy-Con + Utilizza le fotocamere degli occhiali smart per posizionare i controller Joy-Con associati. La rotazione e gli input dei pulsanti provengono dai controller Joy-Con. La posizione viene stimata quando i polsi sono nascosti. Sostituisce i controller utilizzati a mani nude e mette in pausa il tracciamento tramite la fotocamera del telefono. Punta i controller Joy-Con in avanti quando li connetti o reimposti il ​​centro di tracciamento. + Abilita prima il tracciamento della posizione. Richiede controller Joy-Con compatibili con il movimento su Android 12 o versioni successive. Disattivato per impostazione predefinita. + Occhiali smart + Collega gli occhiali smart per modificarne le impostazioni di visualizzazione e tracciamento. Le impostazioni salvate vengono mantenute anche dopo la disconnessione. + VR + Modalità di visualizzazione + Uscita 2D + Uscita 3D + Immagine e schermo virtuale + Posizione e livello del pavimento + Tracciamento delle mani - Sperimentale + Stato del tracciamento + Risoluzione 2D + Risoluzione 3D + Risoluzione VR + Automatica + Uguale a 2D/3D + Risoluzione di output per occhio. + Abilita Gioco su occhiali intelligenti per selezionare la modalità nativa a 30 Hz del display. + Schermo virtuale 3DoF + Ancora i giochi piatti di fronte a te per poterti guardare intorno. Abilita Gioco su occhiali intelligenti senza passare al 3D. + Larghezza e distanza aggiornano immediatamente lo schermo virtuale tracciato per i menu di DroidDeck, i giochi e le sessioni desktop. + Il tracciamento posizionale include la rotazione della testa in SteamVR. Per il tracciamento della sola rotazione, disattiva il tracciamento posizionale. + Controlla il movimento della testa sullo schermo virtuale. Il tracciamento posizionale include la rotazione della testa in SteamVR. + Azioni rapide + Guarda dove desideri che appaia lo schermo, quindi reimposta il centro di tracciamento per impostarne altezza e direzione. + Ricentra i Joy-Con + Fotocamera del telefono - Sperimentale + Tracciare mani o controller Joy-Con + Schermo virtuale 6DoF + Tracciamento posizionale - sperimentale + Movimento fisico in VR e intorno agli schermi virtuali. Il riavvio del tracciamento richiede un attimo. + Altezza attuale degli occhi rispetto al pavimento + Imposta il livello del pavimento dall\'altezza attuale + Imposta il livello del pavimento + Configurazione e diagnostica della telecamera stereo + Verifica la calibrazione della telecamera e il tracciamento delle mani prima di giocare. + Apri la configurazione + Controller utilizzati a mani nude + Usa le telecamere degli occhiali smart per mirare con le mani, pizzica per cliccare e chiudi la mano per afferrare in VR. Gli stick del gamepad si muovono e ruotano. Sostituisce il tracciamento della posizione dei Joy-Con. Potrebbe verificarsi un ritardo o la perdita del tracciamento durante le partite. + Abilita i controller utilizzati a mani nude sotto le telecamere Luma Ultra in Tracciamento. Mostra prima le mani aperte. + Calibrazione Luma Ultra condivisa + Utilizzo della base Luma Ultra condivisa. Calibra i tuoi occhiali intelligenti per verificarne la precisione. + Calibrazione misurata verificata + Validazione richiesta + I controller azionati a mani nude saranno disponibili dopo il superamento del controllo della distanza misurata. + Tracciamento perso + Guardati intorno lentamente in una stanza ben illuminata.\nMantieni le telecamere di tracciamento libere e rivolte verso mobili o altri dettagli visibili. + Ancora bloccato? Sul tuo telefono: occhiali intelligenti → Monitoraggio → Apri configurazione → Mostra diagnostica → Riavvia monitoraggio. + Occhiali intelligenti disconnessi + Controlla la connessione USB e ricollega gli occhiali intelligenti.\nAccetta la richiesta di accesso USB sul telefono, se visualizzata. + Una volta connesso, guardati intorno lentamente in una stanza ben illuminata per ripristinare il tracciamento. + È necessario ricentrare + Il tracciamento è tornato in una nuova posizione.\nGuarda in avanti, quindi tocca \"Ricentra\" sul telefono. + Puoi trovare \"Ricentra\" anche in Occhiali smart → Tracciamento → Apri la configurazione. La calibrazione salvata della fotocamera viene mantenuta. + Resta fermo per un momento + Ripristino del centro di tracciamento in corso.\nMantieni gli Smart Glasses fermi mentre il tracciamento si stabilizza. + Questa schermata si chiude automaticamente quando il tracciamento della testa è pronto. + Mira stabilizzata con le mani + Mira dalla spalla attraverso il palmo della mano. Disattivare per la rotazione controllata dal polso. + Configurazione spaziale + In attesa del tracciamento… + Telecamere di tracciamento sinistra e destra + Sincronizzazione della fotocamera + Pronto + In attesa che la telecamera e il rilevamento della testa si allineino. Mantieni gli occhiali intelligenti collegati. + 1. Preparare il target di calibrazione + Stampa nelle dimensioni reali + Ciascun quadrato deve misurare 30 mm (1,181 pollici). Montare il foglio in piano su una superficie rigida in un\'area ben illuminata. + Stampa il pannello di calibrazione + 2. Cattura punti di vista diversi + Mantenere fermo il target di calibrazione + Avvicinare, allontanare e lateralmente gli occhiali intelligenti. Girali a sinistra/destra, inclinali verso l\'alto/il basso e inclinali lateralmente. Conservare il target di calibrazione in entrambe le fotocamere e fare una breve pausa prima di ogni acquisizione. + Avvia una nuova calibrazione + In attesa della sincronizzazione della fotocamera. + Avviare una nuova calibrazione per raccogliere visualizzazioni. + Mantenere il target di calibrazione visibile in entrambe le anteprime. Cattura almeno 24 viste nitide da diverse angolazioni. + Cattura… + Cattura la vista del target di calibrazione + Calcolare l\'allineamento della telecamera + Calcolo… + Calcolare la calibrazione + 3. Controllare la distanza + Distanza misurata + Iniziare con 12 pollici o 30 cm in modo che gli indicatori stampati siano più facili da rilevare. Scegli la misura esatta che utilizzerai. + Telecamera sinistra al centro del target di calibrazione + Controllo della distanza… + Convalida la distanza + Diagnostica + Mostra diagnostica + Strumenti di recupero della temporizzazione e tracciamento della fotocamera. + Temporizzazione della telecamera + Input dal tracciamento delle mani + In attesa dei tempi della telecamera. + Immagini della telecamera + Rilevamento delle mani tramite GPU + La CPU è l\'impostazione predefinita. La GPU è sperimentale e può causare il riavvio di SteamVR. Questa scelta si reimposta al riavvio del monitoraggio. + Rilevamento rapido dei modelli di mani + Utilizzare il rilevatore di palma Lite e i punti chiave Lite sulle mani. Controlla la precisione della mira, del pizzicotto e della presa. Si reimposta al riavvio del monitoraggio. + Frequenza di ingresso automatica per il tracciamento delle mani + Regola l\'input alla velocità di elaborazione. Si reimposta al riavvio del monitoraggio. + Limita la frequenza di ingresso per il tracciamento delle mani + Utilizzare la metà delle immagini della telecamera. Spegnere per confrontare la frequenza massima. Si reimposta al riavvio del monitoraggio. + Cattura diagnostica + Salva localmente una coppia di immagini stereo. Le immagini vengono salvate solo quando richiesto. + Salva l\'immagine della telecamera + Riavviare il tracciamento + Utilizzare se il tracciamento non viene ripristinato in un\'area ben illuminata. Un riavvio richiede una nuova origine di tracciamento. + Riavvio + Riavviare il monitoraggio? + Le visualizzazioni di calibrazione non salvate andranno perse. Mantieni gli Smart Glasses fermi in seguito e ripristina il centro di tracciamento quando il tracciamento viene ripristinato. + %1$d / 24 visualizzazioni acquisite + Cattura in pausa: %1$s + Misura %1$s. Mostra il target di calibrazione completo in entrambe le anteprime, quindi resta fermo. + %1$.1f Hz • età dell\'immagine %2$.1f ms • elaborazione %3$.1f ms + Limite di ingresso %1$.1f Hz • %2$.0f%% delle immagini della telecamera. Il tracciamento della testa continua alla sua frequenza massima. + %1$d elaborato • %2$d eliminato • %3$d saltato per limite di input + DroidDeck - Calibrazione Luma Ultra + Stampa a 100% / Dimensioni effettive. Ogni quadrato: 30 mm (1,181 pollici). + Mantenere il target di calibrazione piatto e fermo; spostare gli occhiali intelligenti tra le acquisizioni. + Controllo scala: 100 mm (3,937 pollici) tra i tick + 12 pollici (30,48 cm) + 30 cm (11,81 pollici) + 20 pollici (50,8 cm) + 50 cm (19,69 pollici) + Disabilitato + In attesa del tracciamento stabile + Disconnesso + I controller azionati a mani nude sono spenti + Il rilevamento della posizione è disattivato o gli occhiali intelligenti sono disconnessi + Richiesta di ripristino del centro di tracciamento: tieni fermi gli occhiali mentre il tracciamento si stabilizza. + Tracciamento perso: rivolgiti verso un\'area ben illuminata con dettagli visibili + Origine del tracciamento modificata: tocca \"Ricentra\", quindi tieni fermi gli occhiali. + 6DoF attivo + Collegare Luma Ultra e abilitare il tracciamento posizionale. + Calibrazione verificata per questa connessione. + Calibrazione verificata e salvata. + In attesa delle telecamere stereo + In attesa del tracciamento delle mani + Mantenere fermo il target di calibrazione 5 × 7. Cattura oltre 24 visualizzazioni spostando e ruotando gli occhiali intelligenti. + In attesa dell\'immagine successiva della telecamera. Tieni fermi gli occhiali intelligenti. + Controllo dell\'immagine successiva della telecamera. Mantenere visibile l\'intero target di calibrazione e restare fermi. + Avviare prima la calibrazione + Non è arrivata alcuna nuova immagine della fotocamera. Controlla la connessione degli occhiali intelligenti e le anteprime della fotocamera, quindi riprova. + Reimpostazione dell\'orologio della fotocamera + Sistema di coordinate di tracciamento modificato. Le visualizzazioni sono state salvate per il ricalcolo. Ripristina il centro di tracciamento, quindi avvia una nuova configurazione per acquisire altre visualizzazioni. + calibrazione del dispositivo caricata + Calibrazione base Luma Ultra caricata + calibrazione richiesta + Toccare prima Avvia nuova calibrazione. + Il ripristino del centro di tracciamento è in attesa di un tracciamento stabile. Tieni fermi gli occhiali per un momento. + Tracciamento modificato. Tocca \"Ricentra\" una volta, quindi tieni fermi gli occhiali prima di acquisire. + Acquisizione rifiutata: il tracciamento della testa non era sincronizzato oppure è cambiato durante l’acquisizione. Rimani fermo e riprova. + Calcolare l\'allineamento della telecamera prima di controllare la distanza. + elaborazione della fotocamera non riuscita + Il rilevamento della testa è stato modificato durante il rilevamento delle mani + In attesa della sincronizzazione della fotocamera e della testa + Nessun polso rilevato. Tieni le maniglie del controller Joy-Con davanti agli occhiali intelligenti + Nessuna mano rilevata. Mostra i palmi aperti davanti agli occhiali intelligenti + Polsi visibili in una sola telecamera; mantieni gli handle del controller nella vista condivisa + Mani visibili in una sola telecamera; mantieni entrambi i palmi nella vista condivisa + Entrambe le fotocamere vedono le mani, ma la corrispondenza sinistra/destra è ambigua + Mani rilevate, ma la profondità stereo non è coerente + Posizione del polso rifiutata dai controlli stereo o di movimento + Sono stati rilevati punti stereo, ma la geometria del palmo non è coerente + Calibrazione completa e controllo della distanza per abilitare le mani + In attesa di un tracciamento stabile della testa; ripristina il centro di tracciamento se richiesto. + L’osservazione tramite telecamera è troppo vecchia; in attesa di un nuovo paio + Adatta %1$.2f px. Misura la distanza selezionata dalla telecamera sinistra al centro del target di calibrazione, quindi convalida. + OpenCV non disponibile: %1$s + %1$d visualizzazioni salvate ripristinate. Calcola la calibrazione per riprovare o avvia un nuovo set per acquisirne di più. + Acquisito %1$d / 24 visualizzazioni. Mantenere fisso il target di calibrazione; sposta gli occhiali intelligenti per la visualizzazione successiva. + Acquisizione rifiutata: %1$d / 12 angoli obbligatori visibili in entrambe le telecamere. Mostra una parte maggiore del target di calibrazione, resta fermo e riprova. + Impossibile terminare il controllo della distanza: %1$s. Riprova. + Rilevamento delle mani non disponibile: %1$s. Cambia CPU/GPU o attiva/disattiva i controller azionati a mani nude per riprovare. + Il rilevamento delle mani ha superato %1$d ms; osservazione scartata + %1$d / 2 Posizioni del polso dei Joy-Con misurate tramite stereo + Palmi tracciati: %1$d / 2; gesto di pizzico pronto: %2$d; presa pronta: %3$d + Acquisizione diagnostica salvata in %1$s + Tracciamento delle mani interrotto: %1$s + Stereo %1$d×%2$d; %3$s + Il rilevamento della testa e il target di calibrazione non sono d\'accordo di %1$s (limite 5 cm/2 pollici). Mantenere fisso il target di calibrazione e attendere un tracciamento costante prima di iniziare una nuova serie. Ruota e inclina delicatamente gli occhiali intelligenti; fare una pausa prima di ogni acquisizione. + Cattura almeno 24 viste diverse del target di calibrazione stazionario. + Gira gli occhiali intelligenti a sinistra e a destra e inclinali su e giù; il movimento senza rotazione non può calibrare l\'allineamento della fotocamera. + Linea di base della fotocamera non plausibile + Muovi la testa attraverso orientamenti più diversi. + Rotazione telecamera-testa non valida + L\'allineamento telecamera-testa non è coerente. + Impossibile terminare la calibrazione. %1$s Le tue visualizzazioni acquisite vengono salvate. + L\'errore di riproiezione trattenuta %1$.2f px supera i 2 px. Ricalibrare. + %1$d / 24 angoli della scacchiera rilevati in entrambe le fotocamere. Mantenere visibile l\'intero target di calibrazione e restare fermi. Se è già visibile, seleziona 12 pollici o 30 cm e misura la distanza più vicina prima di riprovare. + Il target di calibrazione è visibile, ma la sua profondità non può essere misurata in modo affidabile. Tieni fermi gli occhiali intelligenti e mantieni il target di calibrazione piatto e ben illuminato, quindi riprova. + La ​​misurazione della fotocamera non era valida. Stai fermo e riprova. + Controllo della distanza superato. + Ricontrollare la distanza dalla telecamera sinistra al centro del target di calibrazione, quindi riprovare. + Telecamere misurate %1$s; distanza selezionata %2$s. %3$s + Attendere le anteprime di entrambe le telecamere prima di avviare la calibrazione. + Le visualizzazioni salvate possono essere ricalcolate. Avvia una nuova calibrazione per acquisire il sistema di coordinate di tracciamento corrente. + Mancata corrispondenza del checksum del modello di mano + Impossibile caricare OpenCV + Le impostazioni dello schermo e del tracciamento della testa sono condivise tra menu, giochi e sessioni desktop di DroidDeck. + DroidDeck ChArUco 30 mm diff --git a/app/src/main/res/values-ja/strings.xml b/app/src/main/res/values-ja/strings.xml index 9590f476d0..2df5383a99 100644 --- a/app/src/main/res/values-ja/strings.xml +++ b/app/src/main/res/values-ja/strings.xml @@ -2341,14 +2341,14 @@ 表示 リフレッシュレート 3D(サイドバイサイド) - 左右の目に 3840×1080 の画像の半分ずつを表示します。映像が消えたら、グラスの 2D/3D ボタンを長押ししてください。 + スマートグラスをサイドバイサイド3Dに切り替えます。ヘッドトラッキングは個別に制御されます。 3D 信号を確認できませんでした。2D 映像が戻ってから再試行してください。 映像なし: グラスがこのスマートフォンで出力できないモードになっています。2D/3D ボタンを長押しするか、抜き差ししてください。 3D のリフレッシュレート VR ゲームで 3D SteamVR の実行中は 3D に切り替え、終了後に戻します。 - 3D の映像 - 自動: SteamVR は視界全体に表示し、ほかのゲームは 3D ではスクリーンとして浮かび、2D では平面のままです。 + 画像 + 自動設定では、両眼にフラットコンテンツを表示し、SteamVRを検出します。サイドバイサイドゲーム(SBS)コンテンツの場合は、サイドバイサイドゲームを選択してください。 自動 仮想スクリーン サイドバイサイドのゲーム @@ -2358,20 +2358,20 @@ これらの設定は、「グラスにゲームを表示」がオンで、ゲームがグラスに表示されているときに適用されます。 「自動」では、この 2D ゲームは全画面のままです。幅、距離、ヘッドトラッキングを調整するには、仮想スクリーンを使用してください。 仮想スクリーンを使用 - SteamVR は視界全体に表示されます。視野角は下で調整できます。幅と距離は仮想スクリーンにのみ適用されます。 + SteamVRは画面全体に表示されます。VR内で視野角を調整してください。幅と距離は仮想画面にのみ適用されます。 サイドバイサイドのゲームは、左右の目の視界いっぱいに表示されます。幅と距離は仮想スクリーンにのみ適用されます。 「自動」では、この 2D ゲームは視界の中で固定されます。ヘッドトラッキングを使うには、「表示」で「仮想スクリーン」を選んでください。 ヘッドトラッキングは、仮想スクリーンまたは実行中の SteamVR ゲームに適用されます。 - グラス + デバイス 明るさ 音量 サンブロック 前面のレンズを暗くします。 - ヘッドトラッキング + トラッキング ヘッドトラッキング グラスのセンサーで、頭の動きに合わせて仮想スクリーンと SteamVR を動かします。 視点をリセット - 中央に戻す + 画面の中心をリセット SteamVR の視野角 小さくすると SteamVR が近くなりグラスいっぱいに広がり、大きくすると周囲が広く見えます。 %1$s でプレイ中 @@ -2392,8 +2392,8 @@ 保存したキャリブレーションを削除して、モデルの初期設定に戻しますか?グラスを装着し直したら、中央に戻してください。 リセット ハンドトラッキング - カメラで手をトラッキングしますか? - カメラで手を認識できます。コントローラーが接続されていないときは、素手がそのまま VR の手になります。親指と人差し指をつまむとクリック、手を握るとつかむ、手のひらを自分に向けてつまむとメニューが開きます。Joy-Con を使うときは、手が実際にある位置に Joy-Con を配置します。映像はこのデバイス上で処理され、保存や送信は一切行われません。 + スマートフォンカメラで手やJoy-Conコントローラーをトラッキングしますか? + コントローラーが接続されていない場合、スマートフォンカメラはVR内で素手の動きをトラッキングします。親指と人差し指でつまむとクリック、手を閉じると掴む、手のひらを自分の方に向け、つまむとメニューが開きます。Joy-Conコントローラーがペアリングされている場合、カメラはコントローラーの位置をトラッキングし、Joy-Conコントローラーは回転とボタン入力を行います。画像はこのデバイスで処理され、保存または送信されることはありません。 背面カメラ おすすめです。通常はより鮮明で広角です。 前面カメラ @@ -2401,7 +2401,7 @@ カメラを使う 後で カメラハンドトラッキング - コントローラーが接続されていないときは、手が VR の手になります。つまむとクリック、手のひらを自分に向けてつまむとメニューです。Joy-Con はカメラが見た位置に配置します。映像はこのデバイスの外に出ません。 + スマートフォンのカメラを使って、素手でのジェスチャー操作や、ペアリングしたJoy-ConコントローラーをVR空間に配置することができます。Joy-Conコントローラーは回転とボタン入力を提供します。スマートグラスが手やJoy-Conコントローラーをトラッキングしている間、一時停止します。画像はこのデバイスでのみ処理されます。 カメラ カメラの権限 ハンドトラッキングを開始するには、カメラへのアクセスを許可してください。 @@ -2655,4 +2655,208 @@ %1$s を Steam 用に変換しています。DroidDeck を開いたままにしてください。 この端末ではその動画をデコードできません。 ムービーをインポートできませんでした + スマートグラス + スマートグラスを接続して、ディスプレイと追跡の設定を変更してください。接続を解除しても、保存された設定は保持されます。 + VR + 表示モード + 2D出力 + 3D出力 + 画像と仮想スクリーン + 位置と床面レベル + ハンドトラッキング - 実験的 + トラッキング状態 + 2D解像度 + 3D解像度 + VR解像度 + 自動 + 2D/3Dと同じ + 片目あたりの出力解像度 + スマートグラスでゲームを有効にすると、ディスプレイのネイティブ30Hzモードが選択されます。 + 平面ゲームを目の前に固定して、周囲を見渡せるようにします。3Dに切り替えずにスマートグラスでゲームを有効にします。 + クイックアクション + 画面を表示したい場所を見てから、トラッキングセンターをリセットして画面の高さと方向を設定します。 + スマートフォンカメラ - 実験的機能 + 位置トラッキング - 実験的機能 + VR内および仮想スクリーン周辺での身体の動き。トラッキングの再開には少々時間がかかります。 + 床面からの現在の目の高さ + 現在の高さから床面レベルを設定 + 床面レベルを設定 + ステレオカメラの設定と診断 + プレイ前にカメラのキャリブレーションと手のトラッキングを確認してください。 + セットアップを開く + 素手で操作するコントローラー + 測定されたキャリブレーションが検証されました + 検証が必要です + 測定距離チェックに合格すると、素手で操作できるコントローラーが使用可能になります。 + トラッキングが失われました + Luma Ultraカメラ - 実験的機能 + Joy-Conの位置追跡 + スマートグラスのカメラを使って、ペアリングしたJoy-Conコントローラーの位置を調整します。回転とボタン入力はJoy-Conコントローラーから行われます。手首が隠れている状態では位置が推定されます。素手で操作するコントローラーの代わりに、スマートフォンのカメラによるトラッキングを一時停止します。接続時またはトラッキングセンターをリセットする際は、Joy-Conコントローラーを前方に向けてください。 + まず位置追跡を有効にしてください。Android 12以降を搭載したモーション対応のJoy-Conコントローラーが必要です。デフォルトでは無効になっています。 + ディスプレイとヘッドトラッキングの設定は、DroidDeckのメニュー、ゲーム、デスクトップセッション間で共有されます。 + 3DoF仮想スクリーン + 幅と距離を設定すると、DroidDeckのメニュー、ゲーム、デスクトップセッションのトラッキングされた仮想画面が即座に更新されます。 + 位置トラッキングには、SteamVRでの頭部回転が含まれます。回転のみのトラッキングを行うには、位置トラッキングをオフにしてください。 + 仮想画面上の頭部の動きを制御します。位置トラッキングには、SteamVRでの頭部回転が含まれます。 + Joy-Conの中心をリセット + 手やJoy-Conコントローラーのトラッキング + 6DoF仮想スクリーン + スマートグラスのカメラを使用して、VR内で手で照準を合わせ、ピンチ操作でクリック、手を閉じて掴みます。ゲームパッドのスティックは移動および回転します。Joy-Conの位置トラッキングを置き換えます。ゲーム中にラグが発生したり、トラッキングが失われる場合があります。 + トラッキングのLuma Ultraカメラで、素手で操作するコントローラーを有効にします。最初に開いた手を表示します。 + Luma Ultraの共有キャリブレーション + 共有Luma Ultraベースを使用します。スマートグラスの精度を確認するために、ご自身のスマートグラスをキャリブレーションしてください。 + まだ行き詰まっていますか?携帯電話で: スマートグラス → 追跡 → セットアップを開く → 診断を表示 → 追跡を再開します。 + スマートグラスが切断されました + USB 接続を確認し、スマート グラスを再接続します。\nスマートフォンに USB アクセス プロンプトが表示されたら、これを受け入れます。 + 接続したら、明るい部屋でゆっくり周りを見回して追跡を復元します。 + 中心のリセットが必要です + トラッキングが新しい位置で再開しました。\n正面を向いてから、スマートフォンの「トラッキングセンターのリセット」をタップしてください。 + スマートグラスの「トラッキング」→「セットアップを開く」からも「トラッキングセンターのリセット」が可能です。保存されたカメラキャリブレーションは保持されます。 + ちょっと静止してください + トラッキングセンターのリセット処理中です。\nトラッキングが安定するまで、スマートグラスを動かさないでください。 + ヘッドトラッキングの準備が完了すると、この画面は自動的に閉じます。 + 手による照準の安定化 + 肩から手のひらを通って狙います。手首で回転を制御する場合はオフにします。 + 空間設定 + 追跡を待っています… + 左右の追跡カメラ + カメラ同期 + 準備完了 + カメラとヘッドトラッキングが揃うのを待っています。スマートグラスを接続したままにしてください。 + 1. キャリブレーションターゲットを準備します + 実寸で印刷する + 各正方形の寸法は 30 mm (1.181 インチ) でなければなりません。明るい場所の硬い面にシートを平らに取り付けます。 + キャリブレーションボードを印刷 + 2. さまざまなビューをキャプチャする + キャリブレーションターゲットを静止させます + スマートグラスを近づけたり、遠ざけたり、横に動かしたりします。左右に回転させたり、上下に角度を付けたり、横に傾けたりします。キャリブレーション ターゲットを両方のカメラに保持し、各キャプチャの前に少し停止します。 + 新しいキャリブレーションを開始する + カメラの同期を待っています。 + 新しいキャリブレーションを開始してビューを収集します。 + 両方のプレビューでキャリブレーションターゲットを表示したままにします。さまざまな角度から少なくとも 24 の鮮明なビューを撮影します。 + キャプチャ中… + キャリブレーションターゲットビューのキャプチャ + カメラアライメントを計算する + 計算中… + キャリブレーションを計算する + 3.距離を確認する + 測定距離 + 印刷されたマーカーが検出しやすいように、12 インチまたは 30 cm から始めます。使用する正確な測定値を選択してください。 + 左カメラからキャリブレーションターゲット中心まで + 距離を確認中… + 距離の検証 + 診断 + 診断を表示する + カメラのタイミングおよび追跡回復ツール。 + カメラのタイミング + 手の追跡からの入力 + カメラのタイミングを待っています。 + カメラ画像 + 手のGPU検出 + CPU がデフォルトです。 GPU は実験的なものであるため、SteamVR が再起動する可能性があります。この選択は、追跡が再開されるとリセットされます。 + 手モデルのライト検出 + Lite 手のひら検出器と手の Lite キー ポイントを使用します。照準、ピンチ、グラブの精度を確認します。トラッキングを再開するとリセットされます。 + 手の追跡のための自動入力周波数 + 入力を処理速度に調整します。トラッキングを再開するとリセットされます。 + 手の追跡のための入力周波数を制限する + カメラ画像の半分を使用します。最大周波数を比較する場合はオフにします。トラッキングを再開するとリセットされます。 + 診断キャプチャ + 1 つのステレオ画像ペアをローカルに保存します。画像は要求された場合にのみ保存されます。 + カメラ画像の保存 + 追跡を再開する + 明るい場所でトラッキングが回復しない場合に使用します。再起動には新しい追跡起点が必要です。 + 再起動 + 追跡を再開しますか? + 保存されていないキャリブレーションビューは失われます。その後、スマートグラスを動かさずに、トラッキングが復元されたらトラッキングセンターをリセットしてください。 + %1$d / 24 ビューがキャプチャされました + キャプチャが一時停止されました: %1$s + %1$s を測定します。両方のプレビューで完全なキャリブレーション ターゲットを表示し、静止したままにします。 + %1$.1f Hz • 画像期間 %2$.1f ms • 処理時間 %3$.1f ms + カメラ画像の入力制限 %1$.1f Hz • %2$.0f%%。ヘッドトラッキングは最大周波数で継続します。 + %1$d が処理されました • %2$d がドロップされました • %3$d は入力制限によりスキップされました + DroidDeck - Luma Ultra キャリブレーション + 100% / 実際のサイズで印刷します。各正方形: 30 mm (1.181 インチ)。 + キャリブレーションターゲットを平らで静止した状態に保ちます。キャプチャ間でスマート グラスを移動します。 + スケール チェック: 目盛間 100 mm (3.937 インチ) + 12 インチ (30.48 センチメートル) + 30cm (11.81インチ) + 20 インチ (50.8 センチメートル) + 50cm (19.69インチ) + 無効 + 安定した追跡を待っています + 切断されました + 素手で操作するコントローラーはオフです + 位置追跡がオフになっているか、スマートグラスが接続されていません + トラッキングセンターのリセットが要求されました。トラッキングが安定するまで動かないでください。 + 追跡が失われました — 細部が見える明るい場所に面してください + トラッキングの原点が変更されました。「トラッキングセンターのリセット」をタップしてから、動かないでください。 + 6DoF アクティブ + Luma Ultra を接続し、位置追跡を有効にします。 + この接続のキャリブレーションが検証されました。 + キャリブレーションが検証され、保存されました。 + ステレオカメラ待ち + 手の追跡を待っています + 5 × 7 キャリブレーション ターゲットを静止したままにします。スマートグラスを動かしたり回転させたりしながら、24 以上のビューをキャプチャします。 + 次のカメラ画像を待っています。スマートグラスを動かさないでください。 + 次のカメラ画像を確認します。完全なキャリブレーションターゲットが見える状態を維持し、静止してください。 + まずキャリブレーションを開始します + 新しいカメラ画像が到着しませんでした。スマートグラスの接続とカメラのプレビューを確認してから、再試行してください。 + カメラクロックリセット + トラッキング座標系が変更されました。ビューは再計算のために保存されます。トラッキングセンターをリセットしてから、新しいセットを開始して、さらに多くのビューをキャプチャしてください。 + デバイスキャリブレーションがロードされました + Luma Ultra ベース キャリブレーションをロードしました + 校正が必要です + まず「新しいキャリブレーションを開始」をタップします。 + トラッキングセンターのリセットは、安定したトラッキングを待っています。しばらく動かないでください。 + トラッキングが変更されました。トラッキングセンターのリセットを一度タップし、静止してから撮影してください。 + キャプチャが拒否されました: ヘッド トラッキングが同期されていないか、キャプチャ中に変更されました。静止してもう一度試してください。 + 距離を確認する前にカメラの位置を計算します。 + カメラ処理に失敗しました + 手の検出中にヘッドトラッキングが変更されました + カメラとヘッドの同期待ち + 手首は検出されませんでした。 Joy-Con コントローラーのハンドルをスマートグラスの前に置いてください + 手が検出されませんでした。スマートグラスの前で開いた手のひらを見せる + 手首は 1 台のカメラでのみ表示されます。コントローラーのハンドルを共有ビューに保持します + 手は 1 台のカメラでのみ表示されます。両方の手のひらを共有ビューに保ちます + 両方のカメラで手は見えますが、左右の一致があいまいです + 手は検出されましたが、ステレオの深度が一貫していません + 手首の位置がステレオまたはモーション チェックで拒否されました + ステレオ ポイントが検出されましたが、手のひらのジオメトリが一貫していません + 手のトラッキングを有効にするには、キャリブレーションと距離チェックを完了してください + 安定したヘッドトラッキングを待機中。必要に応じてトラッキングセンターをリセットします。 + カメラによる観察は古すぎる。新しいペアを待っています + %1$.2f ピクセルにフィットします。左側のカメラからキャリブレーション ターゲットの中心までの選択した距離を測定し、検証します。 + OpenCV は利用できません: %1$s + %1$d 個の保存されたビューが復元されました。キャリブレーションを計算して再試行するか、新しいセットを開始してさらにキャプチャします。 + %1$d / 24 ビューをキャプチャしました。キャリブレーションターゲットを固定してください。次のビューのためにスマート グラスを移動します。 + キャプチャが拒否されました: %1$d / 12 個の必須コーナーが両方のカメラに表示されます。キャリブレーション ターゲットをさらに表示し、静止してからもう一度試してください。 + 距離チェックを完了できませんでした: %1$s。もう一度やり直してください。 + 手の検出が利用できません: %1$s。 CPU/GPUを変更するか、素手で操作するコントローラーを切り替えて再試行してください。 + 手の検出が %1$d ミリ秒を超えました。観察は破棄されました + %1$d / 2 Joy-Con の手首の位置をステレオで測定 + 追跡中の手のひら: %1$d / 2、ピンチ可能: %2$d、つかむ操作が可能: %3$d + 診断キャプチャを %1$s に保存しました + 停止した手の追跡: %1$s + ステレオ %1$d×%2$d; %3$s + ヘッドトラッキングとキャリブレーションターゲットは、%1$s (制限 5 cm / 2 インチ) によって一致しません。新しいセットを開始する前に、キャリブレーションターゲットを固定したままにして、安定した追跡を待ちます。スマートグラスをゆっくり回転させたり傾けたりしてください。各キャプチャの前に一時停止します。 + 静止した校正ターゲットの少なくとも 24 のさまざまなビューをキャプチャします。 + スマートグラスを左右に回し、上下に傾けます。回転を伴わない動きではカメラの位置を調整できません。 + 信じられないカメラのベースライン + 頭をより多様な方向に動かします。 + カメラから頭への回転が無効です + カメラとヘッドの位置合わせが一貫していません。 + キャリブレーションを完了できませんでした。 %1$s キャプチャしたビューは保存されます。 + 保留された再投影エラー %1$.2f ピクセルが 2 ピクセルを超えています。再調整します。 + %1$d / 24 個のチェッカーボード コーナーが両方のカメラで検出されました。完全なキャリブレーションターゲットが見える状態を維持し、静止してください。すでに表示されている場合は、12 インチまたは 30 cm を選択し、再試行する前にさらに近い距離を測定します。 + 校正ターゲットは目に見えますが、その深さを確実に測定することはできませんでした。スマート グラスを動かさずに保持し、キャリブレーション ターゲットを平らで明るい状態に保ってから、再試行してください。 + カメラ測定が無効でした。静止してもう一度試してください。 + 距離チェックに合格しました。 + 左カメラからキャリブレーションターゲット中心までの距離を再確認し、再試行してください。 + カメラは %1$s を測定しました。選択された距離 %2$s。 %3$s + キャリブレーションを開始する前に、両方のカメラのプレビューを待ちます。 + 保存されたビューは再計算できます。新しいキャリブレーションを開始して、現在のトラッキング座標系でキャプチャします。 + ハンドモデルのチェックサムの不一致 + OpenCVをロードできませんでした + 明るい部屋でゆっくりと周囲を見回してください。\nトラッキングカメラを遮るものがないように、家具などの見えるものに顔を向けてください。 + DroidDeck ChArUco 30 mm diff --git a/app/src/main/res/values-ko/strings.xml b/app/src/main/res/values-ko/strings.xml index e9ad566d9a..0705efab91 100644 --- a/app/src/main/res/values-ko/strings.xml +++ b/app/src/main/res/values-ko/strings.xml @@ -2341,14 +2341,14 @@ 디스플레이 주사율 3D (사이드 바이 사이드) - 각 눈이 3840×1080 화면의 절반씩을 봅니다. 화면이 끊기면 안경의 2D/3D 버튼을 길게 누르세요. + 스마트 안경을 사이드 바이 사이드 3D 모드로 전환합니다. 헤드 추적은 별도로 제어됩니다. 3D 신호를 확인하지 못했습니다. 2D 화면이 돌아오면 다시 시도하세요. 화면 없음: 안경이 이 휴대폰에서 보낼 수 없는 모드에 있습니다. 2D/3D 버튼을 길게 누르거나 안경을 뺐다가 다시 연결하세요. 3D 주사율 VR 게임에서 3D SteamVR이 실행되는 동안 3D로 전환하고 끝나면 되돌립니다. - 3D 화면 - 자동: SteamVR은 시야 전체를 채우고, 다른 게임은 3D에서는 화면으로 떠 있고 2D에서는 평면으로 보입니다. + 화면 + 자동 모드는 양쪽 눈에 평면 콘텐츠를 표시하고 SteamVR을 감지합니다. SBS 콘텐츠의 경우 \'Side-by-side 게임\'을 선택하세요. 자동 가상 화면 사이드 바이 사이드 게임 @@ -2358,20 +2358,20 @@ 이 설정은 “안경에 게임 표시”가 켜져 있고 게임이 안경에 표시될 때 적용됩니다. “자동”에서는 이 2D 게임이 전체 화면으로 유지됩니다. 너비, 거리, 헤드 트래킹을 조정하려면 가상 화면을 사용하세요. 가상 화면 사용 - SteamVR이 시야를 가득 채웁니다. 아래에서 시야각을 조정하세요. 너비와 거리는 가상 화면에만 적용됩니다. + SteamVR은 화면을 가득 채웁니다. VR 환경에서 시야각을 조정하세요. 너비와 거리는 가상 화면에만 적용됩니다. 사이드 바이 사이드 게임은 양쪽 눈의 시야를 각각 가득 채웁니다. 너비와 거리는 가상 화면에만 적용됩니다. “자동”에서는 이 2D 게임이 시야에 고정됩니다. 헤드 트래킹을 사용하려면 “디스플레이”에서 “가상 화면”을 선택하세요. 헤드 트래킹은 가상 화면이나 실행 중인 SteamVR 게임에 적용됩니다. - 안경 + 장치 밝기 볼륨 선블록 앞쪽 렌즈를 어둡게 합니다. - 헤드 트래킹 + 추적 헤드 트래킹 안경의 센서가 머리 움직임에 맞춰 가상 화면과 SteamVR을 돌립니다. 시점 재설정 - 중앙 맞추기 + 화면 중심 재설정 SteamVR 시야각 낮추면 SteamVR이 가까워져 안경을 가득 채우고, 높이면 주변이 더 넓게 보입니다. %1$s에서 플레이 중 @@ -2392,8 +2392,8 @@ 저장된 보정을 삭제하고 모델 기본값으로 되돌릴까요? 안경을 다시 쓴 후 중앙을 맞추세요. 초기화 핸드 트래킹 - 카메라로 손을 트래킹할까요? - 카메라가 손을 볼 수 있습니다. 컨트롤러가 연결되어 있지 않으면 맨손이 그대로 VR 손이 됩니다. 엄지와 검지를 맞대면 클릭, 손을 쥐면 잡기, 손바닥을 자신 쪽으로 향하고 맞대면 메뉴가 열립니다. Joy-Con을 쓸 때는 손이 실제로 있는 위치에 배치합니다. 영상은 이 기기에서 처리되며 저장되거나 전송되지 않습니다. + 스마트폰 카메라로 손 또는 Joy-Con 컨트롤러 추적? + 컨트롤러가 연결되지 않은 경우, 스마트폰 카메라가 VR 환경에서 맨손을 추적합니다. 엄지와 검지를 오므려 클릭, 손을 오므려 잡기, 손바닥을 자신 쪽으로 돌리고 오므려 메뉴를 엽니다. Joy-Con 컨트롤러가 연결된 경우, 카메라가 컨트롤러의 위치를 ​​추적하는 동안 Joy-Con 컨트롤러는 회전 및 버튼 입력을 제공합니다. 사진은 이 기기에서 처리되며 저장되거나 전송되지 않습니다. 후면 카메라 권장합니다. 보통 더 선명하고 화각이 넓습니다. 전면 카메라 @@ -2401,7 +2401,7 @@ 카메라 사용 나중에 카메라 핸드 트래킹 - 컨트롤러가 연결되어 있지 않으면 손이 VR 손이 됩니다. 손가락을 맞대면 클릭, 손바닥을 자신 쪽으로 향하고 맞대면 메뉴입니다. Joy-Con은 카메라가 보는 위치에 배치합니다. 영상은 이 기기 밖으로 나가지 않습니다. + 휴대폰 카메라를 사용하여 맨손 제스처를 사용하거나 VR에서 페어링된 Joy-Con 컨트롤러의 위치를 ​​조정합니다. Joy-Con 컨트롤러는 회전 및 버튼 입력을 제공합니다. 스마트 안경이 손이나 Joy-Con 컨트롤러를 추적하는 동안 일시 중지됩니다. 이미지는 이 기기에서만 처리됩니다. 카메라 카메라 권한 핸드 트래킹을 시작하려면 카메라 권한을 허용하세요. @@ -2655,4 +2655,208 @@ Steam용으로 %1$s 변환 중입니다. DroidDeck을 열어 두세요. 이 기기에서 해당 동영상을 디코딩할 수 없습니다. 동영상을 가져오지 못했습니다 + Luma Ultra 카메라 — 실험적 기능 + Joy-Con 위치 추적 + 스마트 안경 카메라를 사용하여 페어링된 Joy-Con 컨트롤러의 위치를 ​​조정합니다. 회전 및 버튼 입력은 Joy-Con 컨트롤러에서 이루어집니다. 손목이 가려진 경우 위치가 추정됩니다. 맨손으로 조작하는 컨트롤러를 대체하며, 휴대폰 카메라 추적이 일시 중지됩니다. 추적 센터를 연결하거나 재설정할 때는 Joy-Con 컨트롤러를 앞쪽으로 향하게 하십시오. + 위치 추적을 먼저 활성화해야 합니다. Android 12 이상에서 모션 기능을 지원하는 Joy-Con 컨트롤러가 필요합니다. 기본적으로 비활성화되어 있습니다. + 스마트 안경 + 디스플레이 및 헤드 트래킹 설정은 DroidDeck 메뉴, 게임 및 데스크톱 세션에서 공유됩니다. + 스마트 안경을 연결하여 디스플레이 및 추적 설정을 변경하십시오. 연결을 해제해도 저장된 설정이 유지됩니다. + VR + 표시 모드 + 2D 출력 + 3D 출력 + 화면 및 가상 화면 + 위치 및 층수 + 손 추적 - 실험적 기능 + 추적 상태 + 2D 해상도 + 3D 해상도 + VR 해상도 + 자동 + 2D/3D 동일 + 눈별 출력 해상도 + 스마트 안경에서 게임 기능을 활성화하여 디스플레이의 기본 30Hz 모드를 선택합니다. + 3DoF 가상 화면 + 플랫 게임을 정면에 고정하여 주변을 둘러볼 수 있습니다. 3D 모드로 전환하지 않고도 스마트 안경에서 게임 기능을 활성화할 수 있습니다. + 너비와 거리는 DroidDeck 메뉴, 게임 및 데스크톱 세션에 대해 추적된 가상 화면을 즉시 업데이트합니다. + 위치 추적은 SteamVR에서 머리 회전을 포함합니다. 회전만 추적하려면 위치 추적을 끄세요. + 가상 화면에서 머리 움직임을 제어합니다. 위치 추적은 SteamVR에서 머리 회전을 포함합니다. + 빠른 실행 + 화면을 표시할 위치를 바라본 다음 추적 센터를 재설정하여 높이와 방향을 설정합니다. + Joy-Con 중심 재설정 + 스마트폰 카메라 - 실험적 기능 + 손 또는 Joy-Con 컨트롤러 추적 + 위치 추적 - 실험적 기능 + VR 및 가상 화면 주변에서의 물리적 움직임. 추적을 다시 시작하면 잠시 시간이 걸립니다. + 현재 눈높이(바닥 위) + 현재 높이에서 바닥 높이 설정 + 바닥 높이 설정 + 스테레오 카메라 설정 및 진단 + 게임 시작 전 카메라 보정 및 손 추적을 확인하세요. + 설정 열기 + 맨손으로 조작하는 컨트롤러 + 스마트 안경 카메라를 사용하여 VR에서 손으로 조준하고, 엄지와 검지를 오므려 클릭하고, 손을 오므려 잡으세요. 게임패드 스틱으로 이동하고 방향을 바꿀 수 있습니다. Joy-Con 위치 추적을 대체합니다. 게임 중 지연이 발생하거나 추적이 끊길 수 있습니다. + 추적 설정에서 Luma Ultra 카메라 아래에 맨손으로 조작하는 컨트롤러를 활성화합니다. 먼저 손을 펼친 상태를 표시합니다. + Luma Ultra 공유 보정 + Luma Ultra 공유 베이스 사용 스마트 안경의 정확도를 확인하려면 직접 보정하십시오. + 측정된 보정 확인됨 + 검증 필요 + 측정 거리 확인이 완료되면 맨손으로 조작하는 컨트롤러를 사용할 수 있습니다. + 추적 실패 + 스마트 안경 연결이 끊어졌습니다. + 캡처하는 중… + 왼쪽 카메라에서 보정 대상 중심까지의 거리 + 거리 확인 중… + 거리 확인 + 진단 + 카메라 타이밍 + 카메라 이미지 + Lite 손 추적 모델 + Lite 손바닥 감지 모델과 Lite 손 랜드마크 모델을 사용합니다. 조준, 집기 및 잡기 동작의 정확도를 확인하세요. 추적을 다시 시작하면 초기화됩니다. + 손 추적을 위한 자동 입력 주파수 + 입력을 처리 속도로 조정합니다. 추적이 다시 시작되면 재설정됩니다. + 카메라 이미지 저장 + 추적 다시 시작 + 조명이 밝은 곳에서 추적이 복구되지 않는 경우 사용합니다. 다시 시작하려면 새로운 추적 원본이 필요합니다. + 재시작 + 추적을 다시 시작하시겠습니까? + 저장하지 않은 보정 이미지가 삭제됩니다. 다시 시작한 뒤에는 안경을 움직이지 말고, 추적이 복구되면 중심을 재설정하세요. + %1$d / 24개 보정 이미지 촬영됨 + %1$.1fHz • 이미지 수명 %2$.1fms • 처리 중 %3$.1fms + 카메라 이미지의 입력 제한 %1$.1fHz • %2$.0f%%. 머리 추적은 최대 빈도로 계속됩니다. + %1$d 처리됨 • %2$d 삭제됨 • 입력 제한으로 인해 %3$d 건너뛰음 + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra 보정 + 눈금 확인: 눈금 간 100mm(3.937인치) + 30.48cm(12인치) + 30cm(11.81인치) + 50.8cm(20인치) + 50cm(19.69인치) + 비활성화됨 + 안정적인 추적을 기다리는 중 + 연결 끊김 + 맨손으로 조작하는 컨트롤러는 꺼짐 + 위치 추적이 꺼져 있거나 스마트 안경이 연결되지 않은 경우 + 추적 중심 재설정 요청됨 - 추적이 안정될 때까지 움직이지 마세요. + 추적 손실 - 눈에 보이는 세부 사항이 있는 밝은 조명 영역을 향합니다. + 추적 원점 변경됨 - 추적 중심 재설정을 탭한 다음 움직이지 마세요. + 이 연결에 대한 교정이 확인되었습니다. + 교정이 확인되고 저장되었습니다. + 스테레오 카메라를 기다리는 중 + 카메라 시계 재설정 + 추적 좌표계가 변경되었습니다. 뷰가 재계산을 위해 저장됩니다. 추적 중심을 재설정한 다음 새 세트를 시작하여 더 많은 뷰를 캡처하세요. + 장치 교정 로드됨 + Luma Ultra 기본 보정 로드됨 + 교정이 필요함 + 추적이 변경되었습니다. 캡처하기 전에 추적 중심 재설정을 한 번 탭한 다음 움직이지 마세요. + 카메라 처리 실패 + 손 감지 시 헤드 트래킹이 변경됨 + 두 카메라 모두 손은 보이나 좌우 매칭이 모호함 + 손이 감지되었으나 스테레오 깊이가 일치하지 않습니다. + 스테레오 또는 모션 검사에 의해 손목 위치가 거부됨 + 스테레오 포인트가 감지되었지만 손바닥 형상이 일치하지 않습니다. + %1$.2f픽셀에 맞춥니다. 왼쪽 카메라에서 보정 대상 중심까지 선택한 거리를 측정한 다음 확인합니다. + OpenCV를 사용할 수 없습니다: %1$s + %1$d 저장된 뷰가 복원되었습니다. 다시 시도하려면 보정을 계산하고, 더 많은 것을 캡처하려면 새 세트를 시작하세요. + 캡쳐 %1$d / 조회수 24입니다. 교정 대상을 고정된 상태로 유지하십시오. 다음 보기를 위해 스마트 안경을 이동하세요. + 캡처 거부됨: %1$d / 두 카메라 모두에 12개의 필수 모서리가 표시됩니다. 보정 대상을 더 많이 표시하고 가만히 있다가 다시 시도하세요. + 거리 확인을 완료할 수 없습니다: %1$s. 다시 시도해 보세요. + 손 감지 불가: %1$s. CPU/GPU를 변경하거나 맨손으로 조작하는 컨트롤러를 전환하여 다시 시도하세요. + 손 감지가 %1$dms를 초과했습니다. 관찰이 폐기됨 + %1$d / 스테레오로 측정한 Joy-Con 손목 위치 2개 + 추적 중인 손바닥: %1$d / 2; 집기 준비: %2$d; 잡기 준비: %3$d + 진단 캡처를 %1$s에 저장했습니다. + 잘못된 카메라 대 머리 회전 + 교정을 완료할 수 없습니다. %1$s 캡처한 보기가 저장되었습니다. + 보류 재투영 오류 %1$.2f px가 2px를 초과합니다. 재보정하세요. + 카메라 측정이 잘못되었습니다. 가만히 있다가 다시 시도해 보세요. + 거리 확인이 통과되었습니다. + 손 모델 체크섬 불일치 + OpenCV를 로드할 수 없습니다. + 6DoF 가상 화면 + 조명이 밝은 방에서 천천히 주변을 둘러보세요.\n추적 카메라를 가리지 말고 가구처럼 특징이 뚜렷한 곳을 바라보세요. + 아직도 막혔나요? 휴대폰에서: 스마트 안경 → 추적 → 설정 열기 → 진단 표시 → 추적 다시 시작. + USB 연결을 확인하고 스마트 안경을 다시 연결하세요.\n휴대전화에 USB 액세스 메시지가 나타나면 수락하세요. + 일단 연결되면, 조명이 밝은 방에서 천천히 주위를 둘러보며 추적을 복원하십시오. + 중심 재설정 필요 + 새로운 위치에서 추적이 재개되었습니다.\n앞을 바라본 다음 휴대폰에서 추적 센터 재설정을 탭하세요. + 스마트 안경 → 추적 → 설정 열기에서 추적 중심 재설정을 찾을 수도 있습니다. 저장된 카메라 보정값이 유지됩니다. + 잠시만 가만히 있어주세요 + 추적 중심 재설정이 진행 중입니다.\n추적이 안정될 때까지 스마트 안경을 움직이지 마세요. + 이 화면은 머리 추적이 준비되면 자동으로 닫힙니다. + 손으로 안정화된 조준 + 어깨부터 손바닥까지 조준하세요. 손목으로 제어되는 회전을 사용하려면 끄세요. + 공간 설정 + 추적을 기다리는 중… + 왼쪽 및 오른쪽 추적 카메라 + 카메라 동기화 + 준비 + 카메라와 머리 추적이 정렬되기를 기다리는 중입니다. 스마트 안경을 연결된 상태로 유지하세요. + 1. 교정 타겟 준비 + 실제 크기로 인쇄 + 각 정사각형의 크기는 30mm(1.181인치)여야 합니다. 조명이 밝은 곳의 단단한 표면에 시트를 평평하게 장착합니다. + 보정 패턴 인쇄 + 2. 다양한 뷰 캡처 + 교정 타겟을 고정된 상태로 유지하세요. + 스마트 안경을 더 가까이, 더 멀리, 옆으로 움직여 보세요. 왼쪽/오른쪽으로 돌리고, 위쪽/아래쪽 각도를 맞추고, 옆쪽으로 기울입니다. 두 카메라 모두에서 보정 대상을 유지하고 각 캡처 전에 잠시 일시 중지합니다. + 새로운 교정 시작 + 카메라 동기화를 기다리는 중입니다. + 뷰를 수집하기 위해 새로운 교정을 시작합니다. + 두 미리보기 모두에서 교정 타겟이 표시되도록 유지합니다. 다양한 각도에서 최소 24개의 선명한 뷰를 캡처하세요. + 캡쳐 캘리브레이션 타겟 화면 + 카메라 정렬 계산 + 계산 중… + 교정 계산 + 3. 거리 확인 + 측정된 거리 + 인쇄된 마커를 더 쉽게 감지할 수 있도록 12인치 또는 30cm로 시작하세요. 사용할 정확한 측정값을 선택하세요. + 진단 표시 + 카메라 타이밍 및 추적 복구 도구. + 손 추적을 통한 입력 + 카메라 타이밍을 기다리는 중입니다. + 손의 GPU 감지 + CPU가 기본값이다. GPU는 실험적이므로 SteamVR이 다시 시작될 수 있습니다. 이 선택은 추적이 다시 시작되면 재설정됩니다. + 손 추적을 위한 입력 빈도 제한 + 카메라 이미지의 절반을 사용합니다. 최대 주파수를 비교하려면 끄십시오. 추적이 다시 시작되면 재설정됩니다. + 진단 캡처 + 하나의 스테레오 이미지 쌍을 로컬에 저장합니다. 이미지는 요청한 경우에만 저장됩니다. + 캡처가 일시 중지되었습니다: %1$s + %1$s을 측정한다. 두 미리보기 모두에 전체 보정 대상을 표시한 다음 가만히 기다리세요. + 100% / 실제 크기로 인쇄합니다. 각 정사각형: 30mm(1.181인치). + 교정 대상을 평평하고 고정된 상태로 유지하십시오. 캡처 사이에 스마트 안경을 이동합니다. + 6DoF 활성 + Luma Ultra를 연결하고 위치 추적을 활성화합니다. + 손 추적을 기다리는 중 + 5 × 7 교정 대상을 고정된 상태로 유지하십시오. 스마트 안경을 이동하고 회전하면서 24개 이상의 뷰를 캡처하세요. + 다음 카메라 영상을 기다리는 중입니다. 스마트 안경을 가만히 잡으세요. + 다음 카메라 영상을 확인하는 중입니다. 전체 교정 대상이 보이도록 유지하고 가만히 기다리십시오. + 먼저 캘리브레이션을 시작하세요 + 새로운 카메라 이미지가 도착하지 않았습니다. 스마트 안경 연결 및 카메라 미리보기를 확인한 후 다시 시도하세요. + 먼저 새 보정 시작을 탭합니다. + 추적 중심 재설정이 안정적인 추적을 기다리고 있습니다. 잠시 움직이지 마세요. + 캡처 거부됨: 머리 추적이 동기화되지 않았거나 캡처 중에 변경되었습니다. 움직이지 말고 다시 시도하세요. + 거리를 확인하기 전에 카메라 정렬을 계산하십시오. + 카메라와 헤드의 동기화를 기다리는 중 + 손목이 감지되지 않았습니다. Joy-Con 컨트롤러 핸들을 스마트 안경 앞에 두십시오. + 손이 감지되지 않습니다. 스마트 안경 앞에 손바닥을 펼쳐 보여주세요. + 하나의 카메라에서만 손목이 보입니다. 컨트롤러 핸들을 공유 보기에 유지하세요 + 하나의 카메라에서만 손이 보입니다. 두 손바닥을 공유 보기에 유지 + 손이 활성화되도록 보정 및 거리 확인을 완료합니다. + 안정적인 헤드 추적을 기다리는 중; 요청 시 추적 중심을 재설정하세요. + 카메라 관찰이 너무 오래되었습니다. 새로운 한 쌍을 기다리고 있어요 + 손 추적이 중지됨: %1$s + 스테레오 %1$d×%2$d; %3$s + 머리 추적과 보정 대상이 %1$s(5cm/2인치 제한)만큼 일치하지 않습니다. 교정 대상을 고정된 상태로 유지하고 새 세트를 시작하기 전에 안정적인 추적을 기다립니다. 스마트 안경을 부드럽게 돌리고 기울이세요. 각 캡처 전에 일시 중지합니다. + 고정된 교정 대상에 대해 최소 24개의 다양한 뷰를 캡처합니다. + 스마트 안경을 좌우로 돌리고, 상하로 기울이는 단계; 회전 없는 움직임은 카메라 정렬을 교정할 수 없습니다. + 믿기지 않는 카메라 기준선 + 좀 더 다양한 방향으로 머리를 움직여 보세요. + 카메라와 머리의 정렬이 일관되지 않습니다. + %1$d / 두 카메라 모두에서 24개의 체커보드 모서리가 감지되었습니다. 전체 교정 대상이 보이도록 유지하고 가만히 기다리십시오. 이미 보이는 경우 12인치 또는 30cm를 선택하고 다시 시도하기 전에 더 가까운 거리를 측정합니다. + 교정대상은 보이지만 깊이를 확실하게 측정할 수 없었다. 스마트 안경을 가만히 잡고 보정 대상을 평평하게 유지하고 조명을 밝게 유지한 후 다시 시도하세요. + 왼쪽 카메라에서 캘리브레이션 대상 중심까지의 거리를 다시 확인하고 재시도하세요. + 카메라 측정 %1$s; 선택한 거리 %2$s. %3$s + 보정을 시작하기 전에 두 카메라 미리보기를 모두 기다리세요. + 저장된 뷰는 다시 계산될 수 있습니다. 현재 추적 좌표계에서 캡처하려면 새 보정을 시작하세요. diff --git a/app/src/main/res/values-ms/strings.xml b/app/src/main/res/values-ms/strings.xml index f402bab381..668a2419ba 100644 --- a/app/src/main/res/values-ms/strings.xml +++ b/app/src/main/res/values-ms/strings.xml @@ -2341,14 +2341,14 @@ Paparan Kadar penyegaran 3D (sebelah-menyebelah) - Setiap mata mendapat separuh gambar 3840×1080 sendiri. Jika gambar hilang, tahan butang 2D/3D cermin mata. + Tukar cermin mata pintar kepada 3D bersebelahan. Penjejakan kepala dikawal secara berasingan. Isyarat 3D tidak dapat disahkan. Cuba lagi selepas gambar 2D kembali. Tiada gambar: cermin mata dalam mod yang tidak dapat dihantar oleh telefon ini. Tahan butang 2D/3D-nya, atau cabut dan pasang semula. Kadar penyegaran 3D 3D untuk permainan VR Bertukar kepada 3D semasa SteamVR berjalan, dan kembali selepas itu. - Gambar 3D - Automatik: SteamVR memenuhi pandangan; permainan lain terapung sebagai skrin dalam 3D dan kekal rata dalam 2D. + Gambar + Automatik memaparkan kandungan rata di kedua-dua mata dan mengesan SteamVR. Pilih permainan Side-by-side untuk kandungan SBS. Automatik Skrin maya Permainan 3D sebelah-menyebelah @@ -2358,20 +2358,20 @@ Tetapan ini digunakan semasa Permainan pada cermin mata didayakan dan permainan dipaparkan di sana. Automatik mengekalkan permainan 2D ini dalam skrin penuh. Gunakan skrin maya untuk melaraskan lebar, jarak dan penjejakan kepalanya. Gunakan skrin maya - SteamVR memenuhi pandangan. Laraskan medan pandangannya di bawah; lebar dan jarak hanya digunakan untuk skrin maya. + SteamVR memenuhi paparan. Laraskan medan pandangannya dalam VR; lebar dan jarak hanya terpakai pada skrin maya. Permainan sebelah-menyebelah memenuhi setiap mata. Lebar dan jarak hanya digunakan untuk skrin maya. Automatik mengekalkan permainan 2D ini tetap dalam pandangan. Pilih Skrin maya dalam Paparan untuk menggunakan penjejakan kepala. Penjejakan kepala digunakan untuk skrin maya atau permainan SteamVR yang sedang berjalan. - Cermin mata + Peranti Kecerahan Kelantangan Peredup kanta Menggelapkan kanta hadapan. - Penjejakan kepala + Penjejakan Penjejakan kepala Penderia cermin mata itu sendiri memutarkan skrin maya dan SteamVR mengikut kepala anda. Pusatkan semula paparan - Pusatkan semula + Pusatkan semula skrin Medan pandangan SteamVR Lebih rendah mendekatkan SteamVR dan memenuhi cermin mata; lebih tinggi menunjukkan lebih banyak di sekeliling anda. Bermain pada %1$s @@ -2392,8 +2392,8 @@ Alih keluar penentukuran yang disimpan dan pulihkan tetapan lalai model? Pusatkan semula selepas memakai cermin mata semula. Tetapkan semula Penjejakan tangan - Jejak tangan anda dengan kamera? - Kamera boleh melihat tangan anda. Tanpa pengawal yang disambungkan, tangan kosong anda menjadi tangan VR: rapatkan ibu jari dan jari telunjuk untuk mengklik, genggam tangan untuk memegang, dan hadapkan tapak tangan ke arah anda lalu rapatkan jari untuk membuka menu. Dengan Joy-Con, kamera meletakkannya di tempat tangan anda sebenarnya berada. Gambar diproses pada peranti ini dan tidak pernah disimpan atau dihantar. + Jejaki tangan atau pengawal Joy-Con dengan kamera telefon? + Tanpa pengawal yang disambungkan, kamera telefon menjejaki tangan kosong anda dalam VR: picit ibu jari dan jari telunjuk anda untuk mengklik, tutup tangan anda untuk memegang, dan pusingkan tapak tangan anda ke arah anda dan picit untuk membuka menu. Dengan pengawal Joy-Con yang dipasangkan, kamera menjejaki kedudukannya sementara pengawal Joy-Con menyediakan input putaran dan butang. Gambar diproses pada peranti ini dan tidak pernah disimpan atau dihantar. Kamera belakang Disyorkan. Biasanya lebih jelas dan lebih luas. Kamera depan @@ -2401,7 +2401,7 @@ Gunakan kamera Bukan sekarang Penjejakan tangan dengan kamera - Tanpa pengawal yang disambungkan, tangan anda menjadi tangan VR: rapatkan jari untuk mengklik, hadapkan tapak tangan ke arah anda dan rapatkan jari untuk menu. Dengan Joy-Con, ia meletakkannya di tempat yang dilihat oleh kamera. Gambar kekal pada peranti ini. + Gunakan kamera telefon untuk gerak isyarat tangan kosong atau untuk meletakkan pengawal Joy-Con yang dipasangkan dalam VR. Pengawal Joy-Con menyediakan input putaran dan butang. Berhenti seketika semasa cermin mata pintar menjejaki tangan anda atau pengawal Joy-Con. Imej diproses hanya pada peranti ini. Kamera Akses kamera Benarkan akses kamera supaya penjejakan tangan boleh bermula. @@ -2655,4 +2655,208 @@ Menukar %1$s untuk Steam. Biarkan DroidDeck terbuka. Peranti ini tidak dapat menyahkod video itu. Tidak dapat mengimport video itu + Kamera Luma Ultra — Eksperimen + Penjejakan kedudukan Joy-Con + Gunakan kamera cermin mata pintar untuk meletakkan pengawal Joy-Con yang dipasangkan. Input putaran dan butang datang daripada pengawal Joy-Con. Kedudukan dianggarkan apabila pergelangan tangan anda tersembunyi. Menggantikan pengawal yang dikendalikan dengan tangan kosong dan menjeda penjejakan kamera telefon. Halakan pengawal Joy-Con ke hadapan semasa menyambung atau menetapkan semula pusat penjejakan. + Dayakan penjejakan kedudukan terlebih dahulu. Memerlukan pengawal Joy-Con yang berkemampuan gerakan pada Android 12 atau lebih baharu. Dimatikan secara lalai. + Cermin mata pintar + Tetapan penjejakan paparan dan kepala dikongsi merentasi menu, permainan dan sesi desktop DroidDeck. + Sambungkan cermin mata pintar untuk menukar tetapan paparan dan penjejakannya. Tetapan anda yang disimpan disimpan apabila anda memutuskan sambungan. + VR + Mod paparan + Output 2D + Output 3D + Gambar dan skrin maya + Kedudukan dan aras lantai + Penjejakan tangan — Eksperimen + Status penjejakan + Resolusi 2D + Resolusi 3D + Resolusi VR + Automatik + Sama seperti 2D / 3D + Resolusi output setiap mata. + Dayakan Permainan pada cermin mata pintar untuk memilih mod 30 Hz natif paparan. + Skrin maya 3DoF + Sauhkan permainan rata di hadapan anda supaya anda boleh melihat sekeliling. Mendayakan Permainan pada cermin mata pintar tanpa bertukar kepada 3D. + Lebar dan jarak mengemas kini skrin maya yang dijejaki untuk menu, permainan dan sesi desktop DroidDeck dengan segera. + Penjejakan kedudukan termasuk putaran kepala dalam SteamVR. Untuk penjejakan putaran sahaja, matikan penjejakan kedudukan. + Mengawal pergerakan kepala pada skrin maya. Penjejakan kedudukan termasuk putaran kepala dalam SteamVR. + Tindakan pantas + Lihat di mana anda mahu skrin, kemudian tetapkan semula pusat penjejakan untuk menetapkan ketinggian dan arahnya. + Pusatkan semula Joy-Con + Kamera telefon — Eksperimen + Jejaki tangan atau pengawal Joy-Con + Skrin maya 6DoF + Penjejakan kedudukan — eksperimen + Pergerakan fizikal dalam VR dan di sekitar skrin maya. Memulakan semula penjejakan mengambil masa seketika. + Ketinggian mata semasa di atas lantai + Tetapkan paras lantai daripada ketinggian semasa + Tetapkan paras lantai + Persediaan dan diagnostik kamera stereo + Semak penentukuran kamera dan penjejakan tangan sebelum bermain. + Buka persediaan + Pengawal dikendalikan dengan tangan kosong + Gunakan kamera cermin mata pintar untuk membidik dengan tangan anda, cubit untuk klik dan tutup tangan anda untuk memegang dalam VR. Kayu Gamepad bergerak dan berpusing. Menggantikan penjejakan kedudukan Joy-Con. Mungkin ketinggalan atau kehilangan penjejakan semasa permainan. + Dayakan pengawal dikendalikan dengan tangan kosong di bawah kamera Luma Ultra dalam Penjejakan. Tunjukkan tangan terbuka dahulu. + Penentukuran Luma Ultra Dikongsi + Menggunakan tapak Luma Ultra yang dikongsi. Kalibrasi cermin mata pintar anda sendiri untuk mengesahkan ketepatannya. + Penentukuran yang diukur disahkan + Pengesahan diperlukan + Pengawal yang dikendalikan dengan tangan kosong akan tersedia selepas pemeriksaan jarak yang diukur lulus. + Penjejakan hilang + Lihat sekeliling perlahan-lahan di dalam bilik yang terang benderang.\nPastikan kamera penjejakan jelas dan menghadap perabot atau perincian lain yang boleh dilihat. + Masih buntu? Pada telefon anda: cermin mata pintar → Penjejakan → Buka persediaan → Tunjukkan diagnostik → Mulakan semula penjejakan. + Cermin mata pintar diputuskan sambungan + Periksa sambungan USB dan sambungkan semula cermin mata pintar.\nTerima gesaan akses USB pada telefon anda jika ia muncul. + Setelah disambungkan, lihat sekeliling perlahan-lahan di dalam bilik yang terang untuk memulihkan penjejakan. + Pemusatan semula diperlukan + Penjejakan telah kembali ke kedudukan baharu.\nLihat ke hadapan, kemudian ketik tetapkan semula pusat penjejakan pada telefon anda. + Anda juga boleh menemui pusat penjejakan tetap semula dalam cermin mata pintar → Penjejakan → Buka persediaan. Penentukuran kamera yang disimpan disimpan. + Diamlah seketika + Tetapkan semula pusat penjejakan sedang dijalankan.\nPastikan cermin mata pintar stabil semasa penjejakan stabil. + Skrin ini ditutup secara automatik apabila pengesanan kepala sedia. + Mensasarkan stabil dengan tangan + Halakan dari bahu anda melalui tapak tangan anda. Matikan untuk putaran terkawal pergelangan tangan. + Persediaan ruang + Menunggu penjejakan… + Kamera pengesan kiri dan kanan + Penyegerakan kamera + Sedia + Menunggu pengesanan kamera dan kepala untuk beratur. Pastikan cermin mata pintar disambungkan. + 1. Sediakan sasaran penentukuran + Cetak pada saiz sebenar + Setiap segi empat sama mesti berukuran 30 mm (1.181 in). Lekapkan helaian rata pada permukaan tegar di kawasan yang terang. + Cetak corak penentukuran + 2. Tangkap pandangan yang berbeza + Pastikan sasaran penentukuran tidak bergerak + Gerakkan cermin mata pintar lebih dekat, lebih jauh dan sisi. Pusingkannya ke kiri/kanan, condongkannya ke atas/bawah, dan condongkannya ke sisi. Simpan sasaran penentukuran dalam kedua-dua kamera dan jeda sebentar sebelum setiap tangkapan. + Mulakan penentukuran baharu + Menunggu penyegerakan kamera. + Mulakan penentukuran baharu untuk mengumpul pandangan. + Pastikan sasaran penentukuran kelihatan dalam kedua-dua pratonton. Tangkap sekurang-kurangnya 24 pandangan tajam dari sudut yang berbeza. + Merakam… + Tangkap paparan sasaran penentukuran + Kira penjajaran kamera + Mengira… + Kira penentukuran + 3. Semak jarak + Jarak yang diukur + Mulakan dengan 12 in atau 30 cm supaya penanda yang dicetak lebih mudah untuk dikesan. Pilih ukuran tepat yang akan anda gunakan. + Jarak dari kamera kiri ke pusat sasaran penentukuran + Menyemak jarak… + Sahkan jarak + Diagnostik + Tunjukkan diagnostik + Pemasa kamera dan alat pemulihan penjejakan. + Masa kamera + Input daripada penjejakan tangan + Menunggu pemasaan kamera. + Imej kamera + Pengesanan GPU tangan + CPU ialah lalai. GPU adalah percubaan dan boleh menyebabkan SteamVR dimulakan semula. Pilihan ini ditetapkan semula apabila penjejakan dimulakan semula. + Pengesanan ringan model tangan + Gunakan pengesan tapak tangan Lite dan mata kekunci Lite pada tangan. Periksa ketepatan menyasar, mencubit dan merebut. Ditetapkan semula apabila penjejakan dimulakan semula. + Kekerapan input automatik untuk menjejak tangan + Laraskan input kepada kelajuan pemprosesan. Ditetapkan semula apabila penjejakan dimulakan semula. + Hadkan kekerapan input untuk menjejak tangan + Gunakan separuh imej kamera. Matikan untuk membandingkan kekerapan maksimum. Ditetapkan semula apabila penjejakan dimulakan semula. + Tangkapan diagnostik + Simpan satu pasangan imej stereo secara setempat. Imej disimpan hanya apabila diminta. + Simpan imej kamera + Mulakan semula penjejakan + Gunakan jika penjejakan tidak pulih di kawasan yang terang. Mulakan semula memerlukan asal penjejakan baharu. + Mulakan semula + Mulakan semula penjejakan? + Paparan penentukuran yang tidak disimpan akan hilang. Pastikan cermin mata pintar tidak bergerak selepas itu dan tetapkan semula pusat penjejakan apabila penjejakan dipulihkan. + %1$d / 24 paparan ditangkap + Tangkapan dijeda: %1$s + Ukur %1$s. Tunjukkan sasaran penentukuran lengkap dalam kedua-dua pratonton, kemudian tahan. + %1$.1f Hz • umur imej %2$.1f ms • pemprosesan %3$.1f ms + Had input %1$.1f Hz • %2$.0f%% imej kamera. Pengesanan kepala diteruskan pada kekerapan maksimumnya. + %1$d diproses • %2$d digugurkan • %3$d dilangkau mengikut had input + DroidDeck ChArUco 30 mm + Cetak pada 100% / Saiz sebenar. Setiap segi empat sama: 30 mm (1.181 in). + Pastikan sasaran penentukuran rata dan pegun; gerakkan cermin mata pintar antara tangkapan. + Semakan skala: 100 mm (3.937 in) antara tanda skala + 12 in (30.48 sm) + 30 sm (11.81 in) + 20 in (50.8 sm) + 50 sm (19.69 in) + Dilumpuhkan + Menunggu penjejakan yang stabil + Terputus sambungan + Pengawal yang dikendalikan dengan tangan kosong dimatikan + Penjejakan kedudukan dimatikan atau cermin mata pintar diputuskan + Tetapkan semula pusat penjejakan diminta — tahan pegun semasa penjejakan stabil + Penjejakan hilang — hadapi kawasan yang terang dengan perincian yang boleh dilihat + Asal penjejakan berubah — ketik tetapkan semula pusat penjejakan, kemudian tahan pegun + 6DoF aktif + Sambungkan Luma Ultra dan dayakan penjejakan kedudukan. + Penentukuran disahkan untuk sambungan ini. + Penentukuran disahkan dan disimpan. + Menunggu kamera stereo + Menunggu untuk mengesan tangan + Pastikan sasaran penentukuran 5 × 7 tidak bergerak. Tangkap 24+ paparan sambil menggerakkan dan memutar cermin mata pintar. + Menunggu imej kamera seterusnya. Pegang cermin mata pintar itu. + Menyemak imej kamera seterusnya. Pastikan sasaran penentukuran penuh kelihatan dan tahan. + Mulakan penentukuran dahulu + Tiada imej kamera baharu tiba. Periksa sambungan cermin mata pintar dan pratonton kamera, kemudian cuba semula. + Tetapan semula jam kamera + Sistem koordinat penjejakan berubah. Paparan anda disimpan untuk pengiraan semula. tetapkan semula pusat penjejakan, kemudian mulakan set baharu untuk menangkap lebih banyak paparan. + penentukuran peranti dimuatkan + penentukuran diperlukan + Ketik Mulakan penentukuran baharu dahulu. + Tetapkan semula pusat penjejakan sedang menunggu penjejakan yang stabil. Tahan pegun seketika. + Penjejakan berubah. Ketik tetapkan semula pusat penjejakan sekali, kemudian tahan pegun sebelum menangkap. + Tangkapan ditolak: penjejakan kepala tidak segerak atau telah berubah semasa tangkapan. Kekal diam dan cuba lagi. + Kira penjajaran kamera sebelum menyemak jarak. + pemprosesan kamera gagal + Pengesanan kepala berubah semasa pengesanan tangan + Menunggu penyegerakan kamera dan kepala + Tiada pergelangan tangan dikesan. Simpan pemegang pengawal Joy-Con anda di hadapan cermin mata pintar + Tiada tangan dikesan. Tunjukkan tapak tangan terbuka di hadapan cermin mata pintar + Pergelangan tangan boleh dilihat dalam satu kamera sahaja; simpan pemegang pengawal anda dalam paparan dikongsi + Tangan boleh dilihat dalam satu kamera sahaja; kekalkan kedua tapak tangan dalam pandangan yang dikongsi + Kedua-dua kamera melihat tangan, tetapi padanan kiri/kanan adalah samar-samar + Tangan dikesan, tetapi kedalaman stereo tidak konsisten + Kedudukan pergelangan tangan ditolak oleh pemeriksaan stereo atau gerakan + Mata stereo dikesan, tetapi geometri tapak tangan tidak konsisten + Selesaikan penentukuran dan pemeriksaan jarak untuk membolehkan tangan + Menunggu penjejakan kepala yang stabil; tetapkan semula pusat penjejakan jika diminta + Pemerhatian kamera terlalu lama; menunggu pasangan baru + Muat %1$.2f px. Ukur jarak pilihan anda dari kamera kiri ke pusat sasaran penentukuran, kemudian sahkan. + OpenCV tidak tersedia: %1$s + %1$d paparan yang disimpan dipulihkan. Kira penentukuran untuk mencuba semula, atau mulakan set baharu untuk menangkap lebih banyak lagi. + Ditangkap %1$d / 24 paparan. Pastikan sasaran penentukuran tetap; alihkan cermin mata pintar untuk paparan seterusnya. + Tangkapan ditolak: %1$d / 12 sudut yang diperlukan kelihatan dalam kedua-dua kamera. Tunjukkan lebih banyak sasaran penentukuran, tahan diam, kemudian cuba lagi. + Pemeriksaan jarak tidak dapat diselesaikan: %1$s. Cuba lagi. + Pengesanan tangan tidak tersedia: %1$s. Tukar CPU/GPU atau togol pengawal yang dikendalikan dengan tangan kosong untuk mencuba semula. + Pengesanan tangan melebihi %1$d ms; pemerhatian dibuang + %1$d / 2 kedudukan pergelangan tangan Joy-Con diukur dengan stereo + Tapak tangan dijejak: %1$d / 2; gerak isyarat cubit sedia: %2$d; gerak isyarat genggam sedia: %3$d + Tangkapan diagnostik disimpan ke %1$s + Penjejakan tangan terhenti: %1$s + Stereo %1$d×%2$d; %3$s + Penjejakan kepala dan sasaran penentukuran tidak bersetuju dengan %1$s (had 5 sm / 2 in). Pastikan sasaran penentukuran tetap dan tunggu penjejakan mantap sebelum memulakan set baharu. Pusing dan condongkan cermin mata pintar dengan perlahan; jeda sebelum setiap tangkapan. + Tangkap sekurang-kurangnya 24 pandangan berbeza sasaran penentukuran pegun. + Pusingkan cermin mata pintar ke kiri dan kanan, dan condongkannya ke atas dan ke bawah; pergerakan tanpa putaran tidak boleh menentukur penjajaran kamera. + Garis dasar kamera yang tidak masuk akal + Gerakkan kepala anda melalui orientasi yang lebih pelbagai. + Putaran kamera ke kepala tidak sah + Penjajaran kamera ke kepala tidak konsisten. + Penentukuran tidak dapat diselesaikan. %1$s Pandangan yang ditangkap anda disimpan. + Ralat tayangan semula yang ditahan %1$.2f px melebihi 2 px. Ukur semula. + %1$d / 24 sudut papan dam dikesan dalam kedua-dua kamera. Pastikan sasaran penentukuran penuh kelihatan dan tahan. Jika ia sudah kelihatan, pilih 12 in atau 30 cm dan ukur jarak yang lebih dekat itu sebelum mencuba semula. + Sasaran penentukuran boleh dilihat, tetapi kedalamannya tidak dapat diukur dengan pasti. Pegang cermin mata pintar dan pastikan sasaran penentukuran rata dan terang, kemudian cuba semula. + Ukuran kamera tidak sah. Diam dan cuba lagi. + Semakan jarak lulus. + Semak semula jarak dari kamera kiri ke pusat sasaran penentukuran, kemudian cuba semula. + Kamera diukur %1$s; jarak yang dipilih %2$s. %3$s + Tunggu kedua-dua pratonton kamera sebelum memulakan penentukuran. + Pandangan yang disimpan boleh dikira semula. Mulakan penentukuran baharu untuk ditangkap dalam sistem koordinat penjejakan semasa. + Ketakpadanan checksum model tangan + OpenCV tidak dapat dimuatkan + DroidDeck - Penentukuran Luma Ultra + Penentukuran asas Luma Ultra dimuatkan diff --git a/app/src/main/res/values-nb/strings.xml b/app/src/main/res/values-nb/strings.xml index af17dbf033..5c1ebd5dbe 100644 --- a/app/src/main/res/values-nb/strings.xml +++ b/app/src/main/res/values-nb/strings.xml @@ -2366,14 +2366,14 @@ Skjerm Oppdateringsfrekvens 3D (side ved side) - Hvert øye får sin egen halvdel av et bilde på 3840×1080. Hvis bildet faller ut, holder du inne 2D/3D-knappen på brillene. + Bytt smartbrillene til side-ved-side 3D. Hodesporing styres separat. 3D-signalet ble ikke bekreftet. Prøv igjen når 2D-bildet er tilbake. Ikke noe bilde: brillene er i en modus denne telefonen ikke kan sende. Hold inne 2D/3D-knappen deres, eller koble dem fra og til igjen. 3D-oppdateringsfrekvens 3D for VR-spill Bytter til 3D mens SteamVR kjører, og tilbake etterpå. - 3D-bilde - Automatisk: SteamVR fyller synsfeltet; andre spill svever som en skjerm i 3D og forblir flate i 2D. + Bilde + Automatisk viser flatt innhold i begge øyne og oppdager SteamVR. Velg Side-om-side-spill for SBS-innhold. Automatisk Virtuell skjerm Side-ved-side-spill @@ -2383,20 +2383,20 @@ Disse innstillingene gjelder når Spill i brillene er på og spillet vises der. Automatisk holder dette 2D-spillet i fullskjerm. Bruk en virtuell skjerm for å justere bredde, avstand og hodesporing. Bruk virtuell skjerm - SteamVR fyller hele bildet. Juster synsfeltet nedenfor; bredde og avstand gjelder bare for en virtuell skjerm. + SteamVR fyller visningen. Juster synsfeltet i VR; bredde og avstand gjelder bare for en virtuell skjerm. Side-ved-side-spill fyller hvert øye. Bredde og avstand gjelder bare for en virtuell skjerm. Automatisk holder dette 2D-spillet fast i synsfeltet. Velg Virtuell skjerm under Skjerm for å bruke hodesporing. Hodesporing gjelder for en virtuell skjerm eller et SteamVR-spill som kjører. - Briller + Enhet Lysstyrke Volum Solskjerming Gjør de fremre glassene mørkere. - Hodesporing + Sporing Hodesporing Brillenes egne sensorer dreier den virtuelle skjermen og SteamVR med hodet ditt. Sentrer visningen - Sentrer + Sentrer skjermen på nytt SteamVR-synsfelt Lavere bringer SteamVR nærmere og fyller brillene; høyere viser mer rundt deg. Spiller på %1$s @@ -2417,8 +2417,8 @@ Vil du fjerne den lagrede kalibreringen og gå tilbake til modellens standardverdier? Sentrer når du har tatt på deg brillene igjen. Nullstill Håndsporing - Spor hendene dine med kameraet? - Kameraet kan se hendene dine. Uten tilkoblet kontroller blir de bare hendene dine VR-hendene: klyp sammen tommel og pekefinger for å klikke, lukk hånden for å gripe, og vend håndflaten mot deg og klyp for å åpne menyen. Med Joy-Con plasserer det dem der hendene dine faktisk er. Bilder behandles på denne enheten og lagres eller sendes aldri. + Spore hender eller Joy-Con-kontrollere med telefonkameraet? + Uten en kontroller tilkoblet, sporer telefonkameraet dine bare hender i VR: klyp tommelen og pekefingeren for å klikke, lukk hånden for å gripe, og vri håndflaten mot deg og klyp for å åpne menyen. Med parede Joy-Con-kontrollere sporer kameraet posisjonen deres mens Joy-Con-kontrollerne gir rotasjon og knappinndata. Bilder behandles på denne enheten og lagres eller sendes aldri. Bakre kamera Anbefales. Vanligvis skarpere og bredere. Frontkamera @@ -2426,7 +2426,7 @@ Bruk kamera Ikke nå Håndsporing med kamera - Uten tilkoblet kontroller blir hendene dine VR-hendene: klyp for å klikke, håndflaten mot deg og klyp for menyen. Med Joy-Con plasseres de der kameraet ser dem. Bilder blir på denne enheten. + Bruk telefonkameraet til bevegelser med bare hender eller for å plassere parede Joy-Con-kontrollere i VR. Joy-Con-kontrollere gir rotasjon og knappinndata. Pauser mens smartbrillene sporer hendene eller Joy-Con-kontrollerne dine. Bilder behandles bare på denne enheten. Kamera Kameratilgang Tillat kameratilgang slik at håndsporing kan starte. @@ -2680,4 +2680,208 @@ Konverterer %1$s for Steam. Hold DroidDeck åpen. Enheten kan ikke dekode videoen. Kunne ikke importere videoen + Luma Ultra-kameraer – Eksperimentelt + Joy-Con-posisjonssporing + Bruk smartbrillenes kameraer til å plassere de parede Joy-Con-kontrollerne. Rotasjon og knappinndata kommer fra Joy-Con-kontrollerne. Posisjonen estimeres når håndleddene dine er skjult. Erstatter kontrollere som betjenes med bare hender og pauser sporing av telefonkamera. Rett Joy-Con-kontrollerne fremover når du kobler til eller tilbakestiller sporingssenteret. + Aktiver posisjonssporing først. Krever bevegelseskompatible Joy-Con-kontrollere på Android 12 eller nyere. Av som standard. + Smartbriller + Innstillinger for skjerm- og hodesporing deles på tvers av DroidDeck-menyer, spill og skrivebordsøkter. + Koble til smartbriller for å endre skjerm- og sporingsinnstillingene. De lagrede innstillingene dine beholdes når du kobler fra. + VR + Skjermmodus + 2D-utgang + 3D-utgang + Bilde og virtuell skjerm + Posisjon og gulvnivå + Sporing av hender — Eksperimentell + Sporingsstatus + 2D-oppløsning + 3D-oppløsning + VR-oppløsning + Automatisk + Samme som 2D / 3D + Utgangsoppløsning per øye. + Aktiver Spill på smartbriller for å velge skjermens native 30 Hz-modus. + 3DoF virtuell skjerm + Forankre flate spill foran deg slik at du kan se deg rundt. Aktiverer Spill på smartbriller uten å bytte til 3D. + Bredde og avstand oppdaterer den sporede virtuelle skjermen for DroidDeck-menyer, spill og skrivebordsøkter umiddelbart. + Posisjonssporing inkluderer hoderotasjon i SteamVR. For sporing kun med rotasjon, slå av posisjonssporing. + Kontrollerer hodebevegelse på den virtuelle skjermen. Posisjonssporing inkluderer hoderotasjon i SteamVR. + Hurtighandlinger + Se dit du vil ha skjermen, og tilbakestill deretter sporingssenteret for å angi høyde og retning. + Sentrer Joy-Con på nytt + Telefonkamera – Eksperimentelt + Spore hender eller Joy-Con-kontrollere + 6DoF virtuell skjerm + Posisjonssporing – eksperimentelt + Fysisk bevegelse i VR og rundt virtuelle skjermer. Det tar et øyeblikk å starte sporingen på nytt. + Gjeldende øyehøyde over gulvet + Angi gulvnivå fra gjeldende høyde + Angi gulvnivå + Oppsett og diagnostikk av stereokamera + Sjekk kamerakalibrering og sporing av hender før du spiller. + Åpne oppsett + Kontrollere som betjenes med bare hender + Bruk smartbrillekameraene til å sikte med hendene, klyp for å klikke og lukk hånden for å gripe i VR. Gamepad-spaker beveger seg og snurrer. Erstatter Joy-Con-posisjonssporing. Kan forsinke eller miste sporing under spill. + Aktiver kontrollere som betjenes med bare hender under Luma Ultra-kameraer i Sporing. Vis åpne hender først. + Delt Luma Ultra-kalibrering + Bruk av den delte Luma Ultra-basen. Kalibrer dine egne smartbriller for å bekrefte nøyaktigheten deres. + Målt kalibrering bekreftet + Validering kreves + Kontrollere som betjenes med bare hender blir tilgjengelige etter at den målte avstandskontrollen er bestått. + Sporing tapt + Se deg sakte rundt i et godt opplyst rom.\nHold sikten til sporingskameraene fri og vend deg mot møbler eller andre synlige detaljer. + Fortsatt fast? På telefonen: smartbriller → Sporing → Åpne oppsett → Vis diagnostikk → Start sporing på nytt. + Smarte briller frakoblet + Sjekk USB-tilkoblingen og koble til smartbrillene igjen.\nGodta forespørselen om USB-tilgang på telefonen din hvis den vises. + Når du er tilkoblet, se deg sakte rundt i et godt opplyst rom for å gjenopprette sporingen. + Ny sentrering er nødvendig + Sporingen har returnert i en ny posisjon.\nSe fremover, og trykk deretter på tilbakestill sporingssenteret på telefonen din. + Du finner også tilbakestilling av sporingssenter i smartbriller → Sporing → Åpne oppsett. Din lagrede kamerakalibrering beholdes. + Hold stille et øyeblikk + Tilbakestilling av sporingssenter pågår.\nHold smartbrillene stødige mens sporingen stabiliserer seg. + Denne skjermen lukkes automatisk når hodesporing er klar. + Stabilisert sikting med hendene + Sikt fra skulderen gjennom håndflaten. Slå av for håndleddskontrollert rotasjon. + Romlig oppsett + Venter på sporing... + Venstre og høyre sporingskamera + Kamerasynkronisering + Klar + Venter på at kamera og hodesporing skal stille opp. Hold smartbrillene tilkoblet. + 1. Klargjør kalibreringsmålet + Skriv ut i faktisk størrelse + Hver firkant må være 30 mm (1.181 in). Monter arket flatt på en stiv overflate i et godt opplyst område. + Skriv ut kalibreringsmønster + 2. Ta opp forskjellige visninger + Hold kalibreringsmålet stasjonært + Flytt smartbrillene nærmere, lenger og sidelengs. Snu dem til venstre/høyre, vinkle dem opp/ned og vipp dem sidelengs. Hold kalibreringsmålet i begge kameraene og ta en kort pause før hver opptak. + Start ny kalibrering + Venter på kamerasynkronisering. + Start en ny kalibrering for å samle visninger. + Hold kalibreringsmålet synlig i begge forhåndsvisningene. Ta minst 24 skarpe bilder fra forskjellige vinkler. + Tar opp … + Fange kalibreringsmålvisning + Beregn kamerajustering + Beregner... + Beregn kalibrering + 3. Sjekk avstanden + Målt avstand + Start med 12 tommer eller 30 cm slik at de trykte markørene er lettere å oppdage. Velg den nøyaktige målingen du vil bruke. + Venstre kamera til kalibreringsmålsenter + Sjekker avstand... + Valider avstand + Diagnostikk + Vis diagnostikk + Verktøy for gjenoppretting av kameratiming og sporing. + Kameratiming + Inndata fra sporing av hender + Venter på kameratiming. + Kamerabilder + GPU-deteksjon av hender + CPU er standard. GPU er eksperimentell og kan føre til at SteamVR starter på nytt. Dette valget tilbakestilles når sporingen starter på nytt. + Lite deteksjon av hendermodeller + Bruk Lite håndleddetektor og Lite nøkkelpunkter på hendene. Sjekk sikting, klype og grip nøyaktighet. Tilbakestilles når sporingen starter på nytt. + Automatisk inngangsfrekvens for sporing av hender + Juster input til prosesseringshastighet. Tilbakestilles når sporingen starter på nytt. + Begrens inngangsfrekvens for sporing av hender + Bruk halvparten av kamerabildene. Slå av for å sammenligne maksimal frekvens. Tilbakestilles når sporingen starter på nytt. + Diagnostisk fangst + Lagre ett stereobildepar lokalt. Bilder lagres kun når du blir bedt om det. + Lagre kamerabilde + Start sporing på nytt + Brukes hvis sporingen ikke gjenopprettes i et godt opplyst område. En omstart krever et nytt sporingsopprinnelse. + Start på nytt + Vil du starte sporingen på nytt? + Ulagrede kalibreringsvisninger vil gå tapt. Hold smartbrillene i ro etterpå, og tilbakestill sporingssenteret når sporingen er gjenopprettet. + %1$d / 24 visninger tatt + Opptaket er satt på pause: %1$s + Mål %1$s. Vis hele kalibreringsmålet i begge forhåndsvisningene, og hold deretter stille. + %1$.1f Hz • bildealder %2$.1f ms • behandler %3$.1f ms + Inngangsgrense %1$.1f Hz • %2$.0f%% for kamerabilder. Hodesporing fortsetter med sin maksimale frekvens. + %1$d behandlet • %2$d droppet • %3$d hoppet over inndatagrense + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra-kalibrering + Skriv ut ved 100% / faktisk størrelse. Hver kvadrat: 30 mm (1.181 tommer). + Hold kalibreringsmålet flatt og stasjonært; flytt smartbrillene mellom opptakene. + Skalakontroll: 100 mm (3.937 in) mellom flåttene + 12 tommer (30,48 cm) + 30 cm (11,81 tommer) + 20 tommer (50,8 cm) + 50 cm (19,69 tommer) + Deaktivert + Venter på stabil sporing + Frakoblet + Kontrollere som betjenes med bare hender er av + Posisjonssporing er av eller smartbriller er frakoblet + Tilbakestilling av sporingssenter forespurt – hold stille mens sporingen stabiliserer seg. + Sporing tapt – møt et godt opplyst område med synlige detaljer + Sporingsopprinnelse endret – trykk på tilbakestill sporingssenter, og hold deretter stille. + 6DoF aktiv + Koble til Luma Ultra og aktiver posisjonssporing. + Kalibrering bekreftet for denne forbindelsen. + Kalibrering bekreftet og lagret. + Venter på stereokameraer + Venter på sporing av hender + Hold 5 × 7 kalibreringsmålet stasjonært. Ta 24+ visninger mens du flytter og roterer de smarte brillene. + Venter på neste kamerabilde. Hold de smarte brillene i ro. + Kontrollerer neste kamerabilde. Hold hele kalibreringsmålet synlig og hold stille. + Start kalibreringen først + Det kom ikke noe nytt kamerabilde. Sjekk smartbrilletilkoblingen og forhåndsvisninger av kameraet, og prøv deretter på nytt. + Kameraklokke tilbakestilt + Sporingskoordinatsystem endret. Visningene dine er lagret for ny beregning. Tilbakestill sporingssenter, og start deretter et nytt sett for å fange opp flere visninger. + enhetskalibrering lastet + Luma Ultra basekalibrering lastet + kalibrering kreves + Trykk på Start ny kalibrering først. + Tilbakestill sporingssenter venter på stabil sporing. Hold stille et øyeblikk. + Sporing endret. Trykk på tilbakestill sporingssenter én gang, og hold deretter stille før du tar opptak. + Opptak avvist: Hodesporingen var ikke synkronisert, eller den endret seg under opptaket. Hold deg i ro og prøv igjen. + Beregn kamerajustering før du sjekker avstanden. + kamerabehandling mislyktes + Hodesporing endret under deteksjon av hender + Venter på kamera- og hodesynkronisering + Ingen håndledd oppdaget. Hold Joy-Con-kontrollerhåndtakene foran de smarte brillene + Ingen hender oppdaget. Vis åpne håndflater foran de smarte brillene + Håndledd synlig i bare ett kamera; holde kontrollerhåndtakene i den delte visningen + Hender synlig i bare ett kamera; hold begge håndflatene i den delte visningen + Begge kameraene ser hender, men venstre/høyre-matching er tvetydig + Viser oppdaget, men stereodybden er inkonsekvent + Håndleddsposisjon avvist av stereo- eller bevegelseskontroller + Stereopunkter oppdaget, men palmegeometrien er inkonsekvent + Fullfør kalibrering og avstandssjekk for å aktivere hendene + Venter på stabil hodesporing; tilbakestill sporingssenteret hvis forespurt. + Kameraobservasjon er for gammel; venter på et nytt par + Fit %1$.2f px. Mål den valgte avstanden fra venstre kamera til kalibreringsmålsenteret, og valider deretter. + OpenCV utilgjengelig: %1$s + %1$d lagrede visninger gjenopprettet. Beregn kalibrering for å prøve på nytt, eller start et nytt sett for å fange mer. + Fanget %1$d / 24 visninger. Hold kalibreringsmålet fast; flytt smartbrillene for neste visning. + Opptaket avvist: %1$d / 12 nødvendige hjørner synlige i begge kameraene. Vis mer av kalibreringsmålet, hold stille, og prøv på nytt. + Avstandssjekk kunne ikke fullføres: %1$s. Prøv igjen. + Deteksjon av hender utilgjengelig: %1$s. Bytt CPU/GPU eller bytt kontroller som betjenes med bare hender for å prøve på nytt. + Deteksjon av hender overskredet %1$d ms; observasjon forkastet + %1$d / 2 Joy-Con håndleddsposisjoner målt med stereo + Håndflater sporet: %1$d / 2; klypebevegelse klar: %2$d; gripebevegelse klar: %3$d + Lagret diagnostisk opptak til %1$s + Sporing av hender stoppet: %1$s + Stereo %1$d×%2$d; %3$s + Hodesporing og kalibreringsmålet er uenige med %1$s (grense 5 cm / 2 in). Hold kalibreringsmålet fast og vent på jevn sporing før du starter et nytt sett. Snu og vipp de smarte brillene forsiktig; pause før hver opptak. + Ta minst 24 varierte visninger av det stasjonære kalibreringsmålet. + Snu de smarte brillene til venstre og høyre, og vipp dem opp og ned; bevegelse uten rotasjon kan ikke kalibrere kamerajustering. + Usannsynlig kameragrunnlinje + Beveg hodet gjennom mer varierte orienteringer. + Ugyldig kamera-til-hode-rotasjon + Kamera-til-hode-justering er inkonsekvent. + Kalibreringen kunne ikke fullføres. %1$s Dine visninger lagres. + Utholdt reprojeksjonsfeil %1$.2f px overskrider 2 px. Kalibrer på nytt. + %1$d / 24 sjakkbretthjørner oppdaget i begge kameraene. Hold hele kalibreringsmålet synlig og hold stille. Hvis den allerede er synlig, velg 12 tommer eller 30 cm og mål den nærmere avstanden før du prøver på nytt. + Kalibreringsmålet er synlig, men dybden kunne ikke måles pålitelig. Hold smartbrillene stille og hold kalibreringsmålet flatt og godt opplyst, og prøv deretter på nytt. + Kameramålingen var ugyldig. Hold stille og prøv igjen. + Avstandssjekk bestått. + Kontroller avstanden fra venstre kamera til kalibreringsmålsenteret på nytt, og prøv deretter på nytt. + Kameraer målt %1$s; valgt avstand %2$s. %3$s + Vent på forhåndsvisningene av begge kameraene før du starter kalibreringen. + Lagrede visninger kan beregnes på nytt. Start en ny kalibrering for å fange opp i gjeldende sporingskoordinatsystem. + Uoverensstemmelse med håndmodellsjekksum + OpenCV kunne ikke laste diff --git a/app/src/main/res/values-nl/strings.xml b/app/src/main/res/values-nl/strings.xml index 533f9ce335..46389accad 100644 --- a/app/src/main/res/values-nl/strings.xml +++ b/app/src/main/res/values-nl/strings.xml @@ -2366,14 +2366,14 @@ Scherm Verversingssnelheid 3D (side-by-side) - Elk oog krijgt een eigen helft van een beeld van 3840×1080. Valt het beeld weg, houd dan de 2D/3D-knop van de bril ingedrukt. + Schakel de smart glasses over naar side-by-side 3D. Hoofdtracking wordt apart aangestuurd. Het 3D-signaal is niet bevestigd. Probeer het opnieuw zodra het 2D-beeld terug is. Geen beeld: de bril staat in een modus die deze telefoon niet kan versturen. Houd de 2D/3D-knop ingedrukt, of koppel de bril los en sluit hem opnieuw aan. 3D-verversingssnelheid 3D voor VR-games Schakelt naar 3D zolang SteamVR draait, en daarna weer terug. - 3D-beeld - Automatisch: SteamVR vult het beeld; andere games zweven in 3D als scherm en blijven plat in 2D. + Afbeelding + Automatisch toont platte inhoud in beide ogen en detecteert SteamVR. Kies \'Side-by-side game\' voor SBS-inhoud. Automatisch Virtueel scherm Side-by-side game @@ -2383,20 +2383,20 @@ Deze instellingen gelden zolang Game op bril aanstaat en de game daar wordt getoond. Automatisch houdt deze 2D-game schermvullend. Gebruik een virtueel scherm om breedte, afstand en hoofdtracking aan te passen. Virtueel scherm gebruiken - SteamVR vult het beeld. Pas hieronder het gezichtsveld aan; breedte en afstand gelden alleen voor een virtueel scherm. + SteamVR vult het beeld. Pas het gezichtsveld aan in VR; breedte en afstand zijn alleen van toepassing op een virtueel scherm. Side-by-side games vullen elk oog. Breedte en afstand gelden alleen voor een virtueel scherm. Automatisch houdt deze 2D-game vast in beeld. Kies Virtueel scherm bij Scherm om hoofdtracking te gebruiken. Hoofdtracking geldt voor een virtueel scherm of een actieve SteamVR-game. - Bril + Apparaat Helderheid Volume Zonwering Maakt de voorste glazen donkerder. - Hoofdtracking + Tracking Hoofdtracking De eigen sensoren van de bril laten het virtuele scherm en SteamVR met je hoofd meedraaien. Weergave centreren - Centreren + Scherm opnieuw centreren SteamVR-gezichtsveld Lager brengt SteamVR dichterbij en vult de bril; hoger toont meer om je heen. Je speelt op %1$s @@ -2417,8 +2417,8 @@ De opgeslagen kalibratie verwijderen en de standaardwaarden van het model herstellen? Centreer opnieuw nadat je de bril weer hebt opgezet. Resetten Handtracking - Je handen volgen met de camera? - De camera kan je handen zien. Zonder verbonden controller worden je blote handen de VR-handen: knijp duim en wijsvinger samen om te klikken, sluit je hand om te pakken, en draai je handpalm naar je toe en knijp om het menu te openen. Met Joy-Cons zet de camera ze waar je handen echt zijn. Beelden worden op dit apparaat verwerkt en nooit opgeslagen of verzonden. + Handen of Joy-Con-controllers volgen met de telefooncamera? + Zonder aangesloten controller volgt de telefooncamera je blote handen in VR: knijp met je duim en wijsvinger om te klikken, sluit je hand om te grijpen en draai je handpalm naar je toe en knijp om het menu te openen. Met gekoppelde Joy-Con-controllers volgt de camera hun positie, terwijl de Joy-Con-controllers rotatie en knopbediening mogelijk maken. Foto\'s worden op dit apparaat verwerkt en nooit opgeslagen of verzonden. Achtercamera Aanbevolen. Meestal scherper en breder. Voorcamera @@ -2426,7 +2426,7 @@ Camera gebruiken Niet nu Handtracking via camera - Zonder verbonden controller worden je handen de VR-handen: knijp om te klikken, handpalm naar je toe en knijpen voor het menu. Met Joy-Cons plaatst de camera ze waar hij ze ziet. Beelden blijven op dit apparaat. + Gebruik de telefooncamera voor gebaren met blote handen of om gekoppelde Joy-Con-controllers in VR te positioneren. Joy-Con-controllers bieden rotatie en knopbediening. Pauzeert terwijl de smartbril je handen of Joy-Con-controllers volgt. Beelden worden alleen op dit apparaat verwerkt. Camera Cameratoegang Sta cameratoegang toe zodat handtracking kan starten. @@ -2680,4 +2680,208 @@ %1$s wordt omgezet voor Steam. Houd DroidDeck open. Dit apparaat kan deze video niet decoderen. Kan deze video niet importeren + Luma Ultra-camera\'s — Experimenteel + Positietracking van Joy-Con-controllers + Gebruik de camera\'s van de smartbril om je gekoppelde Joy-Con-controllers te positioneren. Rotatie en knopbediening komen van de Joy-Con-controllers. De positie wordt geschat wanneer je polsen verborgen zijn. Vervangt controllers die met blote handen worden bediend en pauzeert de tracking door de telefooncamera. Richt de Joy-Con-controllers naar voren bij het verbinden of resetten van het trackingcentrum. + Schakel eerst positietracking in. Vereist Joy-Con-controllers met bewegingsondersteuning op Android 12 of hoger. Standaard uitgeschakeld. + Smartbril + Weergave- en hoofdtrackinginstellingen worden gedeeld tussen DroidDeck-menu\'s, games en desktopsessies. + Verbind een smartbril om de weergave- en trackinginstellingen te wijzigen. Je opgeslagen instellingen blijven behouden wanneer je de verbinding verbreekt. + VR + Weergavemodus + 2D-uitvoer + 3D-uitvoer + Beeld en virtueel scherm + Positie en vloerniveau + Handen volgen — Experimenteel + Volgstatus + 2D-resolutie + 3D-resolutie + VR-resolutie + Automatisch + Zelfde als 2D / 3D + Uitvoerresolutie per oog. + Schakel \'Game on smart glasses\' in om de native 30 Hz-modus van het scherm te selecteren. + 3DoF virtueel scherm + Veranker platte games voor je, zodat je om je heen kunt kijken. Schakelt \'Game on smart glasses\' in zonder over te schakelen naar 3D. + Breedte en afstand werken het virtuele scherm voor DroidDeck-menu\'s, games en desktopsessies direct bij. + Positionele tracking omvat hoofdrotatie in SteamVR. Schakel positionele tracking uit voor tracking met alleen rotatie. + Bestuurt hoofdbeweging op het virtuele scherm. Positionele tracking omvat hoofdrotatie in SteamVR. + Snelle acties + Kijk waar je het scherm wilt hebben en reset vervolgens het trackingcentrum om de hoogte en richting in te stellen. + Joy-Con opnieuw centreren + Telefooncamera — Experimenteel + Handen of Joy-Con-controllers volgen + Positietracking — experimenteel + Fysieke beweging in VR en rond virtuele schermen. Het opnieuw starten van de tracking duurt even. + Huidige ooghoogte boven de vloer + Stel het vloerniveau in op basis van de huidige hoogte + Stel het vloerniveau in + Instellingen en diagnostiek van de stereocamera + Controleer de camerakalibratie en de tracking van de handen voordat u gaat spelen. + Instellingen openen + Controllers bediend met blote handen + Gebruik de camera\'s van de smartbril om met uw handen te richten, knijp om te klikken en sluit uw hand om te grijpen in VR. De sticks van de gamepad bewegen en draaien. Vervangt de positietracking van de Joy-Con. Kan vertraging of verlies van tracking tijdens games veroorzaken. + Schakel \'Controllers bediend met blote handen\' in onder Luma Ultra-camera\'s in Tracking. Toon eerst open handen. + Gedeelde Luma Ultra-kalibratie + Gebruik van de gedeelde Luma Ultra-basis. Kalibreer je eigen slimme bril om de nauwkeurigheid te controleren. + Gemeten kalibratie geverifieerd + Validatie vereist + Bedieningselementen die met de blote handen worden bediend, worden beschikbaar nadat de controle van de gemeten afstand is geslaagd. + Tracking verloren + Kijk langzaam rond in een goed verlichte ruimte.\nHoud de trackingcamera\'s vrij en richt ze op meubels of andere zichtbare details. + Zit je nog steeds vast? Op uw telefoon: slimme bril → Volgen → Open instellingen → Diagnose weergeven → Volg opnieuw starten. + Slimme bril losgekoppeld + Controleer de USB-verbinding en sluit de slimme bril opnieuw aan.\nAccepteer de USB-toegangsprompt op uw telefoon als deze verschijnt. + Eenmaal verbonden, kijk langzaam rond in een goed verlichte kamer om de tracking te herstellen. + Opnieuw centreren vereist + Tracking is teruggekeerd op een nieuwe positie.\nKijk naar voren en tik vervolgens op \'Trackingcentrum resetten\' op je telefoon. + Je kunt het resetten van het trackingcentrum ook vinden in de smartbril → Tracking → Instellingen openen. Je opgeslagen camerakalibratie blijft behouden. + Houd even stil + Het resetten van het trackingcentrum is bezig.\nHoud de smartbril stil terwijl de tracking stabiliseert. + Dit scherm sluit automatisch als Head Tracking gereed is. + Gestabiliseerd richten met de handen + Richt vanaf je schouder door je handpalm. Schakel uit voor polsgestuurde rotatie. + Ruimtelijke instellingen + Wachten op tracking… + Volgcamera\'s links en rechts + Camerasynchronisatie + Klaar + Wachten tot camera- en hoofdtracking op één lijn staan. Houd de slimme bril verbonden. + 1. Bereid het kalibratiedoel voor + Afdrukken op ware grootte + Elk vierkant moet 30 mm (1,181 inch) zijn. Monteer de plaat plat op een stevig oppervlak in een goed verlichte ruimte. + Kalibratiepatroon afdrukken + 2. Leg verschillende weergaven vast + Houd het kalibratiedoel stil + Plaats de slimme bril dichterbij, verder en zijwaarts. Draai ze naar links/rechts, kantel ze omhoog/omlaag en kantel ze zijwaarts. Bewaar het kalibratiedoel in beide camera\'s en pauzeer kort voor elke opname. + Nieuwe kalibratie starten + Wachten op camerasynchronisatie. + Start een nieuwe kalibratie om weergaven te verzamelen. + Houd het kalibratiedoel zichtbaar in beide voorbeelden. Leg minimaal 24 scherpe beelden vast vanuit verschillende hoeken. + Vastleggen… + Kalibratiedoelweergave vastleggen + Bereken de camera-uitlijning + Berekenen… + Kalibratie berekenen + 3. Controleer de afstand + Gemeten afstand + Begin met 30 cm of 12 inch, zodat de afgedrukte markeringen gemakkelijker te detecteren zijn. Kies de exacte maat die u gaat gebruiken. + Linkercamera naar midden kalibratiedoel + Afstand controleren… + Afstand valideren + Diagnostiek + Diagnose weergeven + Hersteltools voor cameratiming en tracking. + Cameratiming + Invoer van het volgen van handen + Wachten op cameratiming. + Camerabeelden + GPU-detectie van handen + CPU is de standaardwaarde. GPU is experimenteel en kan ervoor zorgen dat SteamVR opnieuw opstart. Deze keuze wordt gereset wanneer het volgen opnieuw wordt gestart. + Lite-detectie van handmodellen + Gebruik de Lite-handpalmdetector en Lite-sleutelpunten op de handen. Controleer de nauwkeurigheid van richten, knijpen en grijpen. Wordt gereset wanneer het volgen opnieuw wordt gestart. + Automatische invoerfrequentie voor het volgen van handen + Pas de invoer aan de verwerkingssnelheid aan. Wordt gereset wanneer het volgen opnieuw wordt gestart. + Beperk de ingangsfrequentie voor het volgen van handen + Gebruik de helft van de camerabeelden. Schakel uit om de maximale frequentie te vergelijken. Wordt gereset wanneer het volgen opnieuw wordt gestart. + Diagnostische registratie + Eén stereobeeldpaar lokaal opslaan. Afbeeldingen worden alleen opgeslagen als daarom wordt gevraagd. + Camerabeeld opslaan + Start het volgen opnieuw + Gebruiken als de tracking niet herstelt in een goed verlichte ruimte. Voor een herstart is een nieuwe trackingoorsprong vereist. + Opnieuw opstarten + Volgen opnieuw starten? + Niet-opgeslagen kalibratiebeelden gaan verloren. Houd de smartbril daarna stil en reset het trackingcentrum wanneer de tracking is hersteld. + %1$d / 24 weergaven vastgelegd + Opname onderbroken: %1$s + Meet %1$s. Zorg dat het volledige kalibratiedoel in beide cameravoorbeelden zichtbaar is en houd de bril vervolgens stil. + %1$.1f Hz • beeldleeftijd %2$.1f ms • verwerking %3$.1f ms + Ingangslimiet %1$.1f Hz • %2$.0f%% van camerabeelden. Het volgen van het hoofd gaat door op de maximale frequentie. + %1$d verwerkt • %2$d verwijderd • %3$d overgeslagen op invoerlimiet + DroidDeck - Luma Ultra-kalibratie + Afdrukken op 100% / ware grootte. Elk vierkant: 30 mm (1,181 inch). + Houd het kalibratiedoel vlak en stil; verplaats de slimme bril tussen opnames. + Schaalcontrole: 100 mm (3,937 inch) tussen tikken + 12 inch (30,48 cm) + 30 cm (11,81 inch) + 20 inch (50,8 cm) + 50 cm (19,69 inch) + Uitgeschakeld + Wachten op stabiele tracking + Verbinding verbroken + Controllers die met blote handen worden bediend, zijn uitgeschakeld + Positionele tracking is uitgeschakeld of de slimme bril is losgekoppeld + Resetten van het trackingcentrum aangevraagd — blijf stil staan ​​terwijl de tracking stabiliseert. + Tracering verloren: kijk naar een goed verlicht gebied met zichtbare details + Trackingoorsprong gewijzigd — tik op \'Trackingcentrum resetten\' en blijf vervolgens stil staan. + 6DoF actief + Sluit Luma Ultra aan en schakel positionele tracking in. + Kalibratie geverifieerd voor deze verbinding. + Kalibratie geverifieerd en opgeslagen. + Wachten op stereocamera\'s + Wachten op volgen van handen + Houd het 5 × 7-kalibratiedoel stationair. Leg meer dan 24 beelden vast terwijl u de slimme bril beweegt en draait. + Wachten op het volgende camerabeeld. Houd de slimme bril stil. + Het volgende camerabeeld controleren. Houd het volledige kalibratiedoel zichtbaar en blijf stil staan. + Start eerst de kalibratie + Er is geen nieuw camerabeeld binnengekomen. Controleer de slimme brilverbinding en cameravoorbeelden en probeer het opnieuw. + Cameraklok opnieuw instellen + Trackingcoördinatensysteem gewijzigd. Je beelden worden opgeslagen voor herberekening. Reset het trackingcentrum en start een nieuwe set om meer beelden vast te leggen. + apparaatkalibratie geladen + Luma Ultra-basiskalibratie geladen + kalibratie vereist + Tik op Start eerst nieuwe kalibratie. + Het resetten van het trackingcentrum wacht op stabiele tracking. Blijf even stil staan. + Tracking gewijzigd. Tik één keer op \'Trackingcentrum resetten\' en blijf vervolgens stil staan ​​voordat je een opname maakt. + Opname afgewezen: de hoofdtracking was niet gesynchroniseerd of is tijdens de opname veranderd. Houd de bril stil en probeer het opnieuw. + Bereken de camera-uitlijning voordat u de afstand controleert. + Cameraverwerking mislukt + Volgen van hoofd gewijzigd tijdens detectie van handen + Wachten op camera- en hoofdsynchronisatie + Geen polsen gedetecteerd. Houd de handgrepen van uw Joy-Con-controller vóór de slimme bril + Geen handen gedetecteerd. Toon open handpalmen voor de slimme bril + Polsen zichtbaar in slechts één camera; houd uw controllerhandvatten in de gedeelde weergave + Handen zichtbaar in slechts één camera; houd beide handpalmen in het gedeelde zicht + Beide camera\'s zien handen, maar links/rechts matchen is dubbelzinnig + Handen gedetecteerd, maar de stereodiepte is inconsistent + Polspositie afgewezen door stereo- of bewegingscontroles + Stereopunten gedetecteerd, maar de palmgeometrie is inconsistent + Voltooi de kalibratie en de afstandscontrole om de handen in te schakelen + Wachten op stabiele hoofdtracking; reset het trackingcentrum indien aangevraagd. + Cameraobservatie is te oud; wachtend op een nieuw paar + Pas %1$.2f px aan. Meet de door u geselecteerde afstand vanaf de linkercamera tot het midden van het kalibratiedoel en valideer vervolgens. + OpenCV niet beschikbaar: %1$s + %1$d opgeslagen weergaven hersteld. Bereken de kalibratie om het opnieuw te proberen, of start een nieuwe set om meer vast te leggen. + Vastgelegd %1$d / 24 weergaven. Houd het kalibratiedoel vast; verplaats de slimme bril voor de volgende weergave. + Opname afgewezen: %1$d / 12 vereiste hoeken zichtbaar in beide camera\'s. Laat meer van het kalibratiedoel zien, blijf stil staan ​​en probeer het opnieuw. + Afstandscontrole kon niet worden voltooid: %1$s. Probeer het opnieuw. + Detectie van handen niet beschikbaar: %1$s. Wijzig CPU/GPU of schakel controllers die met blote handen worden bediend om het opnieuw te proberen. + De detectie van handen overschreed %1$d ms; observatie weggegooid + %1$d / 2 Joy-Con-polsposities gemeten in stereo + Gevolgde handpalmen: %1$d / 2; knijpgebaar gereed: %2$d; grijpgebaar gereed: %3$d + Diagnostische opname opgeslagen in %1$s + Volgen van handen gestopt: %1$s + Stereo %1$d×%2$d; %3$s + Hoofdtracking en het kalibratiedoel verschillen van elkaar met %1$s (limiet 5 cm / 2 inch). Houd het kalibratiedoel vast en wacht op een stabiele tracking voordat u met een nieuwe set begint. Draai en kantel de slimme bril voorzichtig; pauzeer vóór elke opname. + Leg ten minste 24 gevarieerde weergaven vast van het stationaire kalibratiedoel. + Draai de slimme bril naar links en rechts en kantel hem op en neer; beweging zonder rotatie kan de uitlijning van de camera niet kalibreren. + Ongeloofwaardige camerabasislijn + Beweeg je hoofd door meer gevarieerde oriëntaties. + Ongeldige rotatie van camera naar hoofd + De uitlijning van de camera naar het hoofd is inconsistent. + Kalibratie kon niet worden voltooid. %1$s Uw vastgelegde weergaven worden opgeslagen. + Vastgehouden herprojectiefout %1$.2f px is groter dan 2 px. Opnieuw kalibreren. + %1$d / 24 schaakbordhoeken gedetecteerd in beide camera\'s. Houd het volledige kalibratiedoel zichtbaar en blijf stil staan. Als het al zichtbaar is, selecteert u 12 inch of 30 cm en meet u de kleinere afstand voordat u het opnieuw probeert. + Het kalibratiedoel is zichtbaar, maar de diepte ervan kon niet betrouwbaar worden gemeten. Houd de slimme bril stil en houd het kalibratiedoel vlak en goed verlicht. Probeer het vervolgens opnieuw. + De camerameting was ongeldig. Houd stil en probeer het opnieuw. + Afstandscontrole geslaagd. + Controleer opnieuw de afstand van de linkercamera tot het midden van het kalibratiedoel en probeer het opnieuw. + Camera\'s gemeten %1$s; geselecteerde afstand %2$s. %3$s + Wacht op beide cameravoorbeelden voordat u de kalibratie start. + Opgeslagen weergaven kunnen opnieuw worden berekend. Start een nieuwe kalibratie om vast te leggen in het huidige volgcoördinatensysteem. + Controlesom handmodel komt niet overeen + OpenCV kon niet laden + Virtueel scherm met 6DoF + DroidDeck ChArUco 30 mm diff --git a/app/src/main/res/values-pl/strings.xml b/app/src/main/res/values-pl/strings.xml index 61c698987b..32634d99be 100644 --- a/app/src/main/res/values-pl/strings.xml +++ b/app/src/main/res/values-pl/strings.xml @@ -2416,14 +2416,14 @@ Wyświetlacz Częstotliwość odświeżania 3D (obok siebie) - Każde oko dostaje własną połowę obrazu 3840×1080. Jeśli obraz zniknie, przytrzymaj przycisk 2D/3D na okularach. + Przełącz inteligentne okulary na tryb 3D obok siebie. Śledzenie głowy jest kontrolowane oddzielnie. Nie udało się potwierdzić sygnału 3D. Spróbuj ponownie, gdy wróci obraz 2D. Brak obrazu: okulary są w trybie, którego ten telefon nie obsługuje. Przytrzymaj ich przycisk 2D/3D albo odłącz je i podłącz ponownie. Częstotliwość odświeżania w 3D 3D w grach VR Przełącza na 3D, gdy działa SteamVR, a potem wraca. - Obraz 3D - Automatycznie: SteamVR wypełnia widok; inne gry wiszą jako ekran w 3D i pozostają płaskie w 2D. + Obraz + Automatycznie wyświetla płaską zawartość w obu oczach i wykrywa SteamVR. Wybierz opcję gry obok siebie dla treści SBS. Automatycznie Wirtualny ekran Gra 3D obok siebie @@ -2433,20 +2433,20 @@ Te ustawienia działają, gdy opcja „Gra w okularach” jest włączona, a gra jest tam wyświetlana. Tryb „Automatycznie” pokazuje tę grę 2D na pełnym ekranie. Użyj wirtualnego ekranu, aby dostosować jej szerokość, odległość i śledzenie głowy. Użyj wirtualnego ekranu - SteamVR wypełnia widok. Dostosuj poniżej jego pole widzenia; szerokość i odległość dotyczą tylko wirtualnego ekranu. + SteamVR wypełnia widok. Dostosuj jego pole widzenia w VR; szerokość i odległość dotyczą tylko wirtualnego ekranu. Gry 3D obok siebie wypełniają obraz każdego oka. Szerokość i odległość dotyczą tylko wirtualnego ekranu. Tryb „Automatycznie” utrzymuje tę grę 2D nieruchomo w polu widzenia. Aby używać śledzenia głowy, wybierz „Wirtualny ekran” w sekcji „Wyświetlacz”. Śledzenie głowy działa z wirtualnym ekranem lub uruchomioną grą SteamVR. - Okulary + Urządzenie Jasność Głośność Przyciemnianie Przyciemnia przednie szkła. - Śledzenie głowy + Śledzenie Śledzenie głowy Własne czujniki okularów obracają wirtualny ekran i SteamVR zgodnie z ruchem głowy. Wyśrodkuj widok - Wyśrodkuj + Wyśrodkuj ekran ponownie Pole widzenia SteamVR Mniejsze przybliża SteamVR i wypełnia okulary; większe pokazuje więcej dookoła. Grasz na: %1$s @@ -2467,8 +2467,8 @@ Usunąć zapisaną kalibrację i przywrócić domyślne ustawienia modelu? Po ponownym założeniu okularów wyśrodkuj widok. Resetuj Śledzenie dłoni - Śledzić dłonie za pomocą kamery? - Kamera widzi Twoje dłonie. Gdy nie jest podłączony żaden kontroler, Twoje gołe dłonie stają się dłońmi VR: złącz kciuk i palec wskazujący, aby kliknąć, zaciśnij dłoń, aby chwycić, a żeby otworzyć menu, obróć dłoń wnętrzem do siebie i złącz palce. Z Joy-Conami kamera umieszcza je tam, gdzie naprawdę są Twoje dłonie. Obrazy są przetwarzane na tym urządzeniu i nigdy nie są zapisywane ani wysyłane. + Śledzić dłonie lub kontrolery Joy-Con za pomocą aparatu w telefonie? + Bez podłączonego kontrolera aparat w telefonie śledzi Twoje gołe dłonie w VR: ściśnij kciuk i palec wskazujący, aby kliknąć, zamknij dłoń, aby ją chwycić, obróć dłoń do siebie i ściśnij, aby otworzyć menu. W przypadku sparowanych kontrolerów Joy-Con aparat śledzi ich położenie, a kontrolery Joy-Con umożliwiają obrót i sterowanie przyciskami. Zdjęcia są przetwarzane na tym urządzeniu i nigdy nie są zapisywane ani wysyłane. Tylna kamera Zalecane. Zwykle ostrzejsza i szersza. Przednia kamera @@ -2476,7 +2476,7 @@ Użyj kamery Nie teraz Śledzenie dłoni kamerą - Gdy nie jest podłączony żaden kontroler, Twoje dłonie stają się dłońmi VR: złącz palce, aby kliknąć, a z dłonią zwróconą do siebie, aby otworzyć menu. Z Joy-Conami umieszcza je tam, gdzie widzi je kamera. Obrazy pozostają na tym urządzeniu. + Użyj kamery w telefonie do gestów wykonywanych gołymi rękami lub do ustawienia sparowanych kontrolerów Joy-Con w VR. Kontrolery Joy-Con umożliwiają obrót i sterowanie przyciskami. Wstrzymuje, gdy inteligentne okulary śledzą Twoje dłonie lub kontrolery Joy-Con. Obrazy są przetwarzane tylko na tym urządzeniu. Kamera Dostęp do kamery Zezwól na dostęp do kamery, aby rozpocząć śledzenie dłoni. @@ -2748,4 +2748,208 @@ Konwertowanie %1$s dla Steam. Nie zamykaj DroidDeck. To urządzenie nie może zdekodować tego filmu. Nie udało się zaimportować filmu + Kamery Luma Ultra — Eksperymentalne + Śledzenie pozycji Joy-Conów + Użyj kamer w inteligentnych okularach, aby ustawić sparowane kontrolery Joy-Con. Obrót i sterowanie przyciskami pochodzą z kontrolerów Joy-Con. Pozycja jest szacowana, gdy nadgarstki są ukryte. Zastępuje kontrolery obsługiwane gołymi rękami i wstrzymuje śledzenie kamery telefonu. Skieruj kontrolery Joy-Con do przodu podczas podłączania lub resetowania centrum śledzenia. + Najpierw włącz śledzenie pozycji. Wymaga kontrolerów Joy-Con z obsługą ruchu w systemie Android 12 lub nowszym. Domyślnie wyłączone. + Inteligentne okulary + Ustawienia wyświetlacza i śledzenia głowy są współdzielone w menu DroidDeck, grach i sesjach na komputerze. + Podłącz inteligentne okulary, aby zmienić ich ustawienia wyświetlacza i śledzenia. Zapisane ustawienia zostaną zachowane po rozłączeniu. + VR + Tryb wyświetlania + Wyjście 2D + Wyjście 3D + Obraz i ekran wirtualny + Pozycja i poziom podłogi + Śledzenie dłoni — tryb eksperymentalny + Stan śledzenia + Rozdzielczość 2D + Rozdzielczość 3D + Rozdzielczość VR + Automatyczna + Tak samo jak 2D/3D + Rozdzielczość wyjściowa na oko. + Włącz tryb gry na inteligentnych okularach, aby wybrać natywny tryb 30 Hz wyświetlacza. + Wirtualny ekran 3DoF + Zakotwicz płaskie gry przed sobą, aby móc się rozglądać. Włącza tryb gry na inteligentnych okularach bez przełączania się na tryb 3D. + Szerokość i odległość natychmiast aktualizują śledzony wirtualny ekran dla menu, gier i sesji pulpitu DroidDeck. + Śledzenie położenia obejmuje obrót głowy w SteamVR. Aby śledzić tylko obrót, wyłącz śledzenie położenia. + Steruje ruchem głowy na wirtualnym ekranie. Śledzenie położenia obejmuje obrót głowy w SteamVR. + Szybkie akcje + Spójrz w miejsce, w którym chcesz umieścić ekran, a następnie zresetuj centrum śledzenia, aby ustawić jego wysokość i kierunek. + Wyśrodkuj Joy-Con ponownie + Aparat w telefonie — Eksperymentalny + Śledź dłonie lub kontrolery Joy-Con + Wirtualny ekran 6DoF + Śledzenie położenia — eksperymentalne + Ruch fizyczny w VR i wokół wirtualnych ekranów. Ponowne uruchomienie śledzenia zajmuje chwilę. + Aktualna wysokość oczu nad podłogą + Ustaw poziom podłogi na podstawie aktualnej wysokości + Ustaw poziom podłogi + Konfiguracja i diagnostyka kamery stereo + Sprawdź kalibrację kamery i śledzenie dłoni przed rozpoczęciem gry. + Otwórz konfigurację + Kontrolery obsługiwane gołymi rękami + Użyj kamer okularów inteligentnych do celowania dłońmi, uszczypnij, aby kliknąć, i zamknij dłoń, aby chwycić w VR. Gałki gamepada poruszają się i obracają. Zastępuje śledzenie położenia Joy-Conów. Może wystąpić opóźnienie lub utrata śledzenia podczas gry. + Włącz kontrolery obsługiwane gołymi rękami pod kamerami Luma Ultra w opcji Śledzenie. Najpierw pokaż otwarte dłonie. + Współdzielona kalibracja Luma Ultra + Korzystanie ze wspólnej podstawy Luma Ultra. Skalibruj swoje inteligentne okulary, aby sprawdzić ich dokładność. + Zmierzona kalibracja została zweryfikowana + Wymagana walidacja + Kontrolery obsługiwane gołymi rękami stają się dostępne po pomyślnym przejściu kontroli zmierzonej odległości. + Utrata śledzenia + Rozejrzyj się powoli w dobrze oświetlonym pomieszczeniu.\nUtrzymuj kamery śledzące w czystości i kieruj się na meble lub inne widoczne szczegóły. + Nadal utknąłeś? Na Twoim telefonie: inteligentne okulary → Śledzenie → Otwórz konfigurację → Pokaż diagnostykę → Uruchom ponownie śledzenie. + Inteligentne okulary zostały odłączone + Sprawdź połączenie USB i podłącz ponownie inteligentne okulary.\nZaakceptuj monit o dostęp do USB w telefonie, jeśli się pojawi. + Po podłączeniu rozejrzyj się powoli po dobrze oświetlonym pomieszczeniu, aby przywrócić śledzenie. + Wymagane ponowne wyśrodkowanie + Śledzenie powróciło do nowej pozycji.\nSpójrz przed siebie, a następnie dotknij opcji „Wyśrodkuj” na telefonie. + Opcję „Wyśrodkuj” znajdziesz również w menu „Inteligentne okulary → Śledzenie → Otwórz konfigurację”. Zapisana kalibracja kamery zostanie zachowana. + Nie ruszaj się przez chwilę + Trwa resetowanie centrum śledzenia.\nTrzymaj okulary inteligentne nieruchomo, aż śledzenie się ustabilizuje. + Ten ekran zamyka się automatycznie, gdy śledzenie głowy jest gotowe. + Stabilizowane celowanie rękami + Celuj od ramienia przez dłoń. Wyłącz, aby obracać się sterowanym nadgarstkiem. + Konfiguracja przestrzenna + Oczekiwanie na śledzenie… + Kamery śledzące lewe i prawe + Synchronizacja kamery + Gotowe + Oczekiwanie, aż śledzenie kamery i głowy zrówna się. Utrzymuj połączenie inteligentnych okularów. + 1. Przygotuj cel kalibracyjny + Drukuj w rzeczywistym rozmiarze + Każdy kwadrat musi mieć wymiary 30 mm (1,181 cala). Zamontuj arkusz płasko na sztywnej powierzchni w dobrze oświetlonym miejscu. + Wydrukuj wzorzec kalibracyjny + 2. Uchwyć różne widoki + Utrzymuj cel kalibracji nieruchomo + Przysuń inteligentne okulary bliżej, dalej i na boki. Obróć je w lewo/prawo, ustaw je pod kątem w górę/w dół i przechyl na boki. Zachowaj cel kalibracji w obu aparatach i zatrzymaj się na chwilę przed każdym wykonaniem zdjęcia. + Rozpocznij nową kalibrację + Oczekiwanie na synchronizację kamery. + Rozpocznij nową kalibrację, aby zebrać widoki. + Zachowaj widoczność celu kalibracji w obu podglądach. Uchwyć co najmniej 24 ostre widoki pod różnymi kątami. + Przechwytywanie… + Przechwytywanie widoku celu kalibracji + Oblicz ustawienie kamery + Obliczanie… + Oblicz kalibrację + 3. Sprawdź odległość + Zmierzona odległość + Zacznij od 12 cali lub 30 cm, aby wydrukowane znaczniki były łatwiejsze do wykrycia. Wybierz dokładny pomiar, którego będziesz używać. + Lewa kamera do środka celu kalibracji + Sprawdzanie odległości… + Sprawdź odległość + Diagnostyka + Pokaż diagnostykę + Narzędzia do odzyskiwania synchronizacji i śledzenia kamery. + Czas pracy kamery + Dane wejściowe ze śledzenia rąk + Oczekiwanie na synchronizację kamery. + Obrazy z kamery + Wykrywanie rąk przez GPU + Lite wykrywanie modeli rąk + Użyj detektora dłoni Lite i kluczowych punktów Lite na dłoniach. Sprawdź dokładność celowania, ściskania i chwytania. Resetuje się po ponownym uruchomieniu śledzenia. + Automatyczna częstotliwość wejściowa do śledzenia rąk + Dostosuj wejście do szybkości przetwarzania. Resetuje się po ponownym uruchomieniu śledzenia. + Ogranicz częstotliwość wejściową dla śledzenia dłoni + Wykorzystaj połowę obrazów z kamer. Wyłącz, aby porównać maksymalną częstotliwość. Resetuje się po ponownym uruchomieniu śledzenia. + Przechwytywanie diagnostyczne + Zapisz lokalnie jedną parę obrazów stereo. Obrazy są zapisywane tylko na żądanie. + Zapisz obraz z kamery + Uruchom ponownie śledzenie + Użyj, jeśli śledzenie nie zostaje przywrócone w dobrze oświetlonym obszarze. Ponowne uruchomienie wymaga nowego źródła śledzenia. + Uruchom ponownie + Zrestartować śledzenie? + Niezapisane widoki kalibracji zostaną utracone. Następnie trzymaj okulary inteligentne nieruchomo i zresetuj centrum śledzenia po przywróceniu śledzenia. + Zarejestrowane widoki: %1$d / 24 + Przechwytywanie wstrzymane: %1$s + Zmierz %1$s. Pokaż pełny cel kalibracji w obu podglądach, a następnie przytrzymaj nieruchomo. + %1$.1f Hz • wiek obrazu %2$.1f ms • przetwarzanie %3$.1f ms + Limit wejściowy %1$.1f Hz • %2$.0f%% obrazów z kamer. Śledzenie głowy jest kontynuowane z maksymalną częstotliwością. + %1$d przetworzone • %2$d odrzucone • %3$d pominięte przez limit wejściowy + DroidDeck - Kalibracja Luma Ultra + Drukuj w 100% / Rzeczywisty rozmiar. Każdy kwadrat: 30 mm (1,181 cala). + Utrzymuj cel kalibracji płasko i nieruchomo; przesuwaj inteligentne okulary pomiędzy ujęciami. + Kontrola skali: 100 mm (3,937 cala) pomiędzy znacznikami + 12 cali (30,48 cm) + 30 cm (11,81 cala) + 20 cali (50,8 cm) + 50 cm (19,69 cala) + Wyłączone + Oczekiwanie na stabilne śledzenie + Rozłączono + Kontrolery obsługiwane gołymi rękami są wyłączone + Śledzenie pozycji jest wyłączone lub inteligentne okulary są odłączone + Zażądano zresetowania centrum śledzenia — przytrzymaj w bezruchu, aż śledzenie się ustabilizuje + Utracono śledzenie — zwróć się w stronę dobrze oświetlonego obszaru z widocznymi szczegółami + Zmieniono punkt początkowy śledzenia — dotknij opcji „Wyśrodkuj”, a następnie trzymaj okulary nieruchomo + 6DoF aktywne + Kalibracja zweryfikowana dla tego połączenia. + Kalibracja zweryfikowana i zapisana. + Czekam na kamery stereo + Oczekiwanie na śledzenie rąk + Utrzymuj cel kalibracji 5 × 7 nieruchomo. Uchwyć ponad 24 widoki podczas przesuwania i obracania inteligentnych okularów. + Oczekiwanie na kolejny obraz z kamery. Trzymaj inteligentne okulary nieruchomo. + Sprawdzanie obrazu z kolejnej kamery. Utrzymuj widoczny pełny cel kalibracji i trzymaj nieruchomo. + Najpierw rozpocznij kalibrację + Nie dotarł nowy obraz z kamery. Sprawdź połączenie inteligentnych okularów i podgląd aparatu, a następnie spróbuj ponownie. + Reset zegara aparatu + Zmieniono układ współrzędnych śledzenia. Twoje widoki zostały zapisane do ponownego obliczenia. Zresetuj centrum śledzenia, a następnie rozpocznij nowy zestaw, aby uchwycić więcej widoków. + Załadowano kalibrację urządzenia + Załadowano kalibrację bazową Luma Ultra + wymagana kalibracja + Najpierw dotknij „Rozpocznij nową kalibrację”. + Resetowanie centrum śledzenia oczekuje na stabilne śledzenie. Przytrzymaj w bezruchu przez chwilę. + Zmieniono śledzenie. Dotknij raz opcji „Wyśrodkuj”, a następnie trzymaj okulary nieruchomo przed wykonaniem zdjęcia. + Odrzucono zdjęcie: śledzenie głowy nie było zsynchronizowane lub zmieniło się podczas wykonywania zdjęcia. Nie ruszaj się i spróbuj ponownie. + Oblicz ustawienie kamery przed sprawdzeniem odległości. + Przetwarzanie kamery nie powiodło się + Zmieniono śledzenie głowy podczas wykrywania rąk + Oczekiwanie na synchronizację kamery i głowy + Nie wykryto nadgarstków. Trzymaj uchwyty kontrolera Joy-Con przed inteligentnymi okularami + Nie wykryto rąk. Pokaż otwarte dłonie przed inteligentnymi okularami + Nadgarstki widoczne tylko w jednym aparacie; trzymaj uchwyty kontrolera w widoku udostępnionym + Dłonie widoczne tylko w jednej kamerze; trzymaj obie dłonie we wspólnym widoku + Obie kamery widzą ręce, ale dopasowanie lewa/prawa jest niejednoznaczne + Wykryto ręce, ale głębia stereo jest niespójna + Pozycja nadgarstka odrzucona przez kontrolę stereo lub ruchu + Wykryto punkty stereo, ale geometria dłoni jest niespójna + Zakończ kalibrację i sprawdź odległość, aby włączyć ręce + Oczekiwanie na stabilne śledzenie głowy; zresetuj centrum śledzenia, jeśli zostaniesz o to poproszony. + Obserwacja kamerą jest zbyt stara; czekam na świeżą parę + Dopasuj %1$.2f pikseli. Zmierz wybraną odległość od lewej kamery do środka celu kalibracji, a następnie zatwierdź. + OpenCV niedostępne: %1$s + Przywrócono %1$d zapisane widoki. Oblicz kalibrację, aby spróbować ponownie, lub rozpocznij nową serię, aby uchwycić więcej. + Zarejestrowane widoki: %1$d / 24. Utrzymuj cel kalibracji nieruchomo; przesuń inteligentne okulary, aby uzyskać następny widok. + Przechwytywanie odrzucone: %1$d / 12 wymaganych rogów widocznych w obu kamerach. Pokaż więcej celu kalibracji, przytrzymaj nieruchomo i spróbuj ponownie. + Sprawdzanie odległości nie mogło zostać zakończone: %1$s. Spróbuj ponownie. + Wykrywanie rąk przekroczyło %1$d ms; obserwacja odrzucona + %1$d / 2 pozycje nadgarstków Joy-Con mierzone metodą stereo + Śledzone dłonie: %1$d / 2; gest szczypania gotowy: %2$d; chwyt gotowy: %3$d + Zapisano przechwytywanie diagnostyczne w %1$s + Zatrzymano śledzenie rąk: %1$s + Stereo %1$d×%2$d; %3$s + Śledzenie głowy i cel kalibracji różnią się o %1$s (limit 5 cm / 2 cale). Utrzymuj cel kalibracji na stałym poziomie i poczekaj na stabilne śledzenie przed rozpoczęciem nowej serii. Delikatnie obracaj i przechylaj inteligentne okulary; pauza przed każdym uchwyceniem. + Uchwyć co najmniej 24 różne widoki stacjonarnego celu kalibracji. + Obracaj inteligentne okulary w lewo i w prawo oraz przechyl je w górę i w dół; ruch bez obrotu nie może skalibrować wyrównania kamery. + Nieprawdopodobna linia bazowa kamery + Poruszaj głową w bardziej zróżnicowanych orientacjach. + Nieprawidłowy obrót kamery względem głowy + Ustawienie kamery względem głowy jest niespójne. + Kalibracja nie mogła zostać ukończona. %1$s Twoje przechwycone widoki są zapisywane. + Błąd wstrzymania ponownego odwzorowania %1$.2f px przekracza 2 px. Ponowna kalibracja. + %1$d / 24 rogi szachownicy wykryte w obu kamerach. Utrzymuj widoczny pełny cel kalibracji i trzymaj nieruchomo. Jeśli jest już widoczny, wybierz 12 cali lub 30 cm i zmierz tę bliższą odległość przed ponowną próbą. + Cel kalibracji jest widoczny, ale nie można wiarygodnie zmierzyć jego głębokości. Trzymaj inteligentne okulary nieruchomo, a cel kalibracji powinien być płaski i dobrze oświetlony, a następnie spróbuj ponownie. + Pomiar kamery był nieprawidłowy. Zatrzymaj się i spróbuj ponownie. + Kontrola odległości zaliczona. + Sprawdź ponownie odległość od lewej kamery do środka celu kalibracji i spróbuj ponownie. + Kamery zmierzyły %1$s; wybrana odległość %2$s. %3$s + Przed rozpoczęciem kalibracji poczekaj na podgląd z obu kamer. + Zapisane widoki można przeliczyć. Rozpocznij nową kalibrację, aby przechwycić bieżący układ współrzędnych śledzenia. + Niezgodność sumy kontrolnej modelu ręki + Nie można załadować OpenCV + Domyślnie używany jest CPU. GPU jest opcją eksperymentalną i może powodować ponowne uruchamianie SteamVR. Wybór jest resetowany po ponownym uruchomieniu śledzenia. + DroidDeck ChArUco 30 mm + Podłącz Luma Ultra i włącz śledzenie pozycji. + Wykrywanie dłoni jest niedostępne: %1$s. Zmień ustawienie CPU/GPU lub wyłącz i ponownie włącz sterowanie dłońmi, aby spróbować ponownie. diff --git a/app/src/main/res/values-pt-rPT/strings.xml b/app/src/main/res/values-pt-rPT/strings.xml index 771109e64e..b33f525235 100644 --- a/app/src/main/res/values-pt-rPT/strings.xml +++ b/app/src/main/res/values-pt-rPT/strings.xml @@ -2377,14 +2377,14 @@ Ecrã Taxa de atualização 3D (lado a lado) - Cada olho recebe a sua metade de uma imagem de 3840×1080. Se a imagem desaparecer, mantenha premido o botão 2D/3D dos óculos. + Alterne os óculos inteligentes para 3D lado a lado. O rastreio da cabeça é controlado separadamente. O sinal 3D não foi confirmado. Tenta novamente quando a imagem 2D voltar. Sem imagem: os óculos estão num modo que este telemóvel não consegue enviar. Mantenha premido o botão 2D/3D ou desligue-os e volte a ligá-los. Taxa de atualização em 3D 3D para jogos de RV Muda para 3D enquanto o SteamVR está em execução e volta depois. - Imagem 3D - Automático: o SteamVR preenche a vista; os outros jogos flutuam como um ecrã em 3D e ficam planos em 2D. + Imagem + O modo automático apresenta conteúdo plano em ambos os olhos e deteta o SteamVR. Selecione Jogo lado a lado para conteúdo SBS. Automático Ecrã virtual Jogo lado a lado @@ -2394,20 +2394,20 @@ Estas definições aplicam-se enquanto Jogo nos óculos estiver ativado e o jogo for mostrado nos óculos. O modo Automático mantém este jogo 2D em ecrã inteiro. Utilize um ecrã virtual para ajustar a largura, a distância e o seguimento da cabeça. Utilizar ecrã virtual - O SteamVR preenche a vista. Ajuste o campo de visão abaixo; a largura e a distância aplicam-se apenas a um ecrã virtual. + O SteamVR preenche a pré-visualização. Ajuste o seu campo de visão em VR; a largura e a distância aplicam-se apenas a um ecrã virtual. Os jogos lado a lado preenchem a vista de cada olho. A largura e a distância aplicam-se apenas a um ecrã virtual. O modo Automático mantém este jogo 2D fixo na vista. Escolha Ecrã virtual na secção Ecrã para utilizar o seguimento da cabeça. O seguimento da cabeça aplica-se a um ecrã virtual ou a um jogo do SteamVR em execução. - Óculos + Dispositivo Brilho Volume Escurecimento Escurece as lentes frontais. - Seguimento da cabeça + Rastreio Seguimento da cabeça Os sensores dos próprios óculos rodam o ecrã virtual e o SteamVR com a sua cabeça. Recentrar vista - Recentrar + Recentralizar ecrã Campo de visão do SteamVR Mais baixo aproxima o SteamVR e preenche os óculos; mais alto mostra mais à sua volta. A jogar em %1$s @@ -2428,8 +2428,8 @@ Remover a calibração guardada e repor as predefinições do modelo? Recentre depois de voltar a colocar os óculos. Repor Seguimento das mãos - Seguir as tuas mãos com a câmara? - A câmara consegue ver as tuas mãos. Sem nenhum comando ligado, as tuas mãos livres passam a ser as mãos de RV: junta o polegar e o indicador para clicar, fecha a mão para agarrar e, para abrir o menu, vira a palma para ti e junta os dedos. Com Joy-Con, coloca-os onde as tuas mãos estão realmente. As imagens são processadas neste dispositivo e nunca são guardadas nem enviadas. + Rastrear mãos ou comandos Joy-Con com a câmara do telemóvel? + Sem qualquer comando ligado, a câmara do telemóvel segue as suas mãos nuas em VR: junte o polegar e o indicador para clicar, feche a mão para agarrar e vire a palma da mão na sua direção e junte para abrir o menu. Com os controlos Joy-Con emparelhados, a câmara acompanha a sua posição enquanto os controlos Joy-Con fornecem rotação e entradas de botão. As imagens são processadas neste dispositivo e nunca são guardadas ou enviadas. Câmara traseira Recomendada. Costuma ser mais nítida e ampla. Câmara frontal @@ -2437,7 +2437,7 @@ Utilizar câmara Agora não Seguimento das mãos pela câmara - Sem nenhum comando ligado, as tuas mãos passam a ser as mãos de RV: junta os dedos para clicar e, com a palma virada para ti, junta-os para abrir o menu. Com Joy-Con, coloca-os onde a câmara os vê. As imagens ficam neste dispositivo. + Utilize a câmara do telefone para gestos com as mãos nuas ou para posicionar os controlos Joy-Con emparelhados em RV. Os comandos Joy-Con proporcionam rotação e comandos dos botões. Pausa enquanto os óculos inteligentes rastreiam as suas mãos ou os comandos Joy-Con. As imagens são processadas apenas neste dispositivo. Câmara Acesso à câmara Permita o acesso à câmara para que o seguimento das mãos possa começar. @@ -2705,4 +2705,208 @@ A converter %1$s para o Steam. Mantenha o DroidDeck aberto. Este dispositivo não consegue descodificar esse vídeo. Não foi possível importar esse vídeo + Câmaras Luma Ultra — Experimental + Rastreio de posição do Joy-Con + Utilize as câmaras dos óculos inteligentes para posicionar os seus comandos Joy-Con emparelhados. A rotação e os comandos dos botões vêm dos comandos Joy-Con. A posição é estimada quando os seus pulsos estão escondidos. Substitui os controlos operados com as mãos nuas e pausa o rastreio da câmara do telefone. Aponte os controlos Joy-Con para a frente ao ligar ou repor o centro de seguimento. + Ative primeiro o seguimento de posição. Requer comandos Joy-Con com sensor de movimento no Android 12 ou posterior. Desativado por defeito. + Óculos inteligentes + As definições de visualização e rastreio de cabeça são partilhadas entre os menus do DroidDeck, jogos e sessões da área de trabalho. + Ligue os óculos inteligentes para alterar as suas definições de visualização e rastreio. As suas configurações guardadas são mantidas ao desconectar. + VR + Modo de visualização + Saída 2D + Saída 3D + Imagem e ecrã virtual + Posição e nível do piso + Rastreio de mãos — Experimental + Estado do rastreio + Resolução 2D + Resolução 3D + Resolução VR + Automático + Igual ao 2D/3D + Resolução de saída por olho. + Ative a funcionalidade \"Jogar em óculos inteligentes\" para selecionar o modo nativo de 30 Hz do ecrã. + Ecrã virtual 3DoF + Ancore jogos planos à sua frente para que possa olhar em redor. Ativa a funcionalidade \"Jogar em óculos inteligentes\" sem alternar para 3D. + A largura e a distância atualizam o ecrã virtual rastreado para menus, jogos e sessões de ambiente de trabalho do DroidDeck imediatamente. + O seguimento posicional inclui a rotação da cabeça no SteamVR. Para o seguimento apenas de rotação, desative o seguimento posicional. + Controla o movimento da cabeça no ecrã virtual. O seguimento posicional inclui a rotação da cabeça no SteamVR. + Ações rápidas + Olhe para onde pretende que o ecrã fique e, em seguida, reponha o centro de rastreio para definir a sua altura e direção. + Recentralizar Joy-Con + Câmara do telemóvel — Experimental + Rastrear mãos ou comandos Joy-Con + Ecrã virtual 6DoF + Rastreio posicional — experimental + Movimento físico em RV e em torno de ecrãs virtuais. Reiniciar o rastreio demora um instante. + Altura atual dos olhos em relação ao chão + Definir nível do chão a partir da altura atual + Definir nível do chão + Configuração e diagnóstico da câmara estéreo + Verifique a calibração da câmara e o seguimento das mãos antes de jogar. + Abrir configuração + Controladores operados com as mãos nuas + Utilize as câmaras dos óculos inteligentes para fazer pontaria com as mãos, faça o gesto de pinça para clicar e feche a mão para agarrar em VR. Os joysticks do gamepad movem-se e giram. Substitui o seguimento de posição do Joy-Con. Pode haver atraso ou perda de rastreio durante os jogos. + Ative os controladores operados com as mãos nuas sob as câmaras Luma Ultra em Rastreio. Mostre primeiro as mãos abertas. + Calibração partilhada do Luma Ultra + Utilizando a base partilhada do Luma Ultra. Calibre os seus próprios óculos inteligentes para verificar a sua precisão. + Calibração medida verificada + Validação necessária + Os controladores operados com as mãos nuas ficam disponíveis após a verificação da distância medida ser aprovada. + Rastreio perdido + Ainda preso? No seu telefone: óculos inteligentes → Rastreio → Abrir configuração → Mostrar diagnóstico → Reiniciar rastreio. + Óculos inteligentes desligados + Verifique a ligação USB e volte a ligar os óculos inteligentes.\nAceite o pedido de acesso USB no seu telefone, se este aparecer. + Uma vez ligado, olhe lentamente em redor numa sala bem iluminada para restaurar o rastreio. + É necessário recentralizar + O rastreio retornou numa nova posição.\nOlhe em frente e toque em repor centro de rastreio no seu telefone. + Também pode encontrar a opção de repor o centro de seguimento em óculos inteligentes → Rastreio → Abrir configuração. A sua calibração de câmara salva será mantida. + Fique imóvel por um momento + A reposição do centro de seguimento está em curso.\nMantenha os óculos inteligentes firmes enquanto o rastreio estabiliza. + Este ecrã fecha automaticamente quando o rastreio da cabeça está pronto. + Mira estabilizada com as mãos + Aponte do ombro até à palma da mão. Desligue para rotação controlada pelo pulso. + Configuração espacial + Aguarda rastreio… + Câmaras de seguimento esquerda e direita + Sincronização da câmara + Pronto + Aguarda o alinhamento da câmara e do seguimento da cabeça. Mantenha os óculos inteligentes ligados. + 1. Preparar o alvo de calibração + Imprimir em tamanho real + Cada quadrado deverá medir 30 mm (1.181 in). Monte a folha plana sobre uma superfície rígida numa área bem iluminada. + Imprimir padrão de calibração + 2. Capturar diferentes visualizações + Mantenha o alvo de calibração estacionário + Aproxime, afaste e lateralmente os óculos inteligentes. Vire-os para a esquerda/direita, incline-os para cima/para baixo e incline-os lateralmente. Mantenha o alvo de calibração em ambas as câmaras e faça uma breve pausa antes de cada captura. + Iniciar nova calibração + Aguarda sincronização da câmara. + Iniciar uma nova calibração para recolher visualizações. + Mantenha o alvo de calibração visível em ambas as visualizações. Capte pelo menos 24 visualizações nítidas de diferentes ângulos. + Capturar… + Capturar visualização do alvo de calibração + Calcular o alinhamento da câmara + Calculando… + Calcular calibração + 3. Verifique a distância + Distância medida + Comece com 12 pol. ou 30 cm para que os marcadores impressos sejam mais fáceis de detetar. Escolha a medida exata que vai utilizar. + Câmara esquerda para o centro do alvo de calibração + Verificação de distância… + Validar distância + Diagnóstico + Mostrar diagnóstico + Ferramentas de temporização e recuperação do seguimento da câmara. + Tempo da câmara + Entrada do rastreio de mãos + Aguardar o tempo da câmara. + Imagens da câmara + Detecção de mãos por GPU + CPU é o padrão. A GPU é experimental e pode fazer com que o SteamVR reinicie. Esta escolha é reposta quando o rastreio é reiniciado. + Detecção Lite de modelos de mãos + Utilize o detetor de palma Lite e os pontos-chave Lite nas mãos. Verifique a mira, aperte e agarre a precisão. Repõe quando o rastreio é reiniciado. + Frequência de entrada automática para rastreio de mãos + Ajuste a entrada à velocidade de processamento. Repõe quando o rastreio é reiniciado. + Limitar a frequência de entrada para rastreio de mãos + Utilize metade das imagens da câmara. Desligue para comparar a frequência máxima. Repõe quando o rastreio é reiniciado. + Captura de diagnóstico + Guarde localmente um par de imagens estéreo. As imagens são guardadas apenas quando solicitadas. + Guardar imagem da câmara + Reiniciar o rastreio + Utilize se o rastreio não for recuperado numa área bem iluminada. Uma reinicialização requer uma nova origem de rastreio. + Reiniciar + Reiniciar o rastreio? + As visualizações de calibração não guardadas serão perdidas. Mantenha os óculos inteligentes imóveis posteriormente e volte a definir o centro de rastreio quando o rastreio for restaurado. + %1$d / 24 visualizações capturadas + Captura em pausa: %1$s + Medida %1$s. Mostre o alvo de calibração completo em ambas as visualizações e mantenha-se imóvel. + %1$.1f Hz • idade da imagem %2$.1f ms • processamento %3$.1f ms + Limite de entrada %1$.1f Hz • %2$.0f%% de imagens da câmara. O rastreio da cabeça continua na sua frequência máxima. + %1$d processado • %2$d descartado • %3$d ignorado pelo limite de entrada + DroidDeck ChArUco 30 mm + DroidDeck - Calibração Luma Ultra + Imprimir a 100%/tamanho real. Cada quadrado: 30 mm (1,181 pol.). + Mantenha o alvo de calibração plano e estacionário; mova os óculos inteligentes entre capturas. + Verificação da escala: 100 mm (3,937 pol.) entre marcas + 30,48 cm (12 pol.) + 30 cm (11,81 pol.) + 50,8 cm (20 pol.) + 50 cm (19,69 pol.) + Desativado + Aguarda rastreio estável + Desligado + Os controladores operados com as mãos nuas estão desligados + O seguimento posicional está desativado ou os óculos inteligentes estão desligados + Reposição do centro de seguimento solicitada — mantenha os óculos imóveis enquanto o seguimento estabiliza. + Rastreio perdido — enfrente uma área bem iluminada com detalhes visíveis + Origem do seguimento alterada — toque em repor o centro de seguimento e mantenha os óculos imóveis. + 6DoF ativo + Ligue o Luma Ultra e ative o rastreio posicional. + Calibração verificada para esta ligação. + Calibração verificada e guardada. + Esperando por câmaras estéreo + Aguarda rastreamento de mãos + Mantenha o alvo de calibração 5 × 7 estacionário. Capte mais de 24 visualizações enquanto move e roda os óculos inteligentes. + Aguarda-se a próxima imagem da câmara. Segure os óculos inteligentes imóveis. + Verificação da próxima imagem da câmara. Mantenha o alvo de calibração completo visível e permaneça imóvel. + Inicie primeiro a calibração + Não chegou nenhuma imagem nova da câmara. Verifique a ligação dos óculos inteligentes e as visualizações da câmara e tente novamente. + Reinicialização do relógio da câmara + Sistema de coordenadas de rastreio alterado. As suas visualizações foram guardadas para recálculo. Reponha o centro de rastreio e inicie um novo conjunto para captar mais visualizações. + calibração do dispositivo carregada + Calibração básica do Luma Ultra carregada + calibração necessária + Toque primeiro em Iniciar nova calibração. + A reposição do centro de rastreio está a aguardar um rastreio estável. Mantenha os óculos imóveis por um momento. + Rastreio alterado. Toque em repor o centro de rastreio uma vez e mantenha os óculos imóveis antes de capturar. + Captura rejeitada: o rastreio da cabeça estava fora de sincronia ou mudou durante a captura. Fique imóvel e tente novamente. + Calcule o alinhamento da câmara antes de verificar a distância. + falha no processamento da câmara + Rastreio da cabeça alterado durante a deteção das mãos + Aguarda sincronização da câmara e da cabeça + Nenhum pulso detetado. Mantenha as pegas do comando Joy-Con na frente dos óculos inteligentes + Nenhuma mão detectada. Mostre as palmas das mãos abertas à frente dos óculos inteligentes + Pulsos visíveis em apenas uma câmara; mantenha as pegas do comando na vista partilhada + Mãos visíveis em apenas uma câmara; mantenha as duas palmas na visualização partilhada + Ambas as câmaras veem mãos, mas a correspondência esquerda/direita é ambígua + Mãos detetadas, mas a profundidade estéreo é inconsistente + Posição do pulso rejeitada por verificações de estéreo ou de movimento + Pontos estéreo detetados, mas a geometria da palma é inconsistente + Conclua a calibração e a verificação de distância para ativar o rastreio de mãos + Aguarda rastreio de cabeça estável; reponha o centro de rastreio se solicitado. + A observação da câmara é muito antiga; à espera de um novo par + Ajustar %1$.2f px. Meça a distância selecionada da câmara esquerda até ao centro do alvo de calibração e valide. + OpenCV indisponível: %1$s + %1$d visualizações guardadas restauradas. Calcule a calibração para tentar novamente ou inicie um novo conjunto para captar mais. + Capturado %1$d/24 visualizações. Mantenha o alvo de calibração fixo; mova os óculos inteligentes para a visualização seguinte. + Captura rejeitada: %1$d/12 cantos necessários visíveis em ambas as câmaras. Mostre mais do alvo de calibração, mantenha-se imóvel e tente novamente. + A verificação da distância não pôde ser concluída: %1$s. Tente novamente. + Detecção de mãos indisponível: %1$s. Troque a CPU/GPU ou alterne os controladores operados com as mãos nuas para tentar novamente. + A deteção de mãos excedeu os %1$d ms; observação descartada + %1$d / 2 posições de pulso do Joy-Con medidas por estéreo + Palmas seguidas: %1$d / 2; gesto de pinça pronto: %2$d; gesto de agarrar pronto: %3$d + Captura de diagnóstico guardada em %1$s + Rastreio de mãos interrompido: %1$s + Estéreo %1$d×%2$d; %3$s + O seguimento da cabeça e o alvo de calibração discordam em %1$s (limite de 5 cm/2 pol.). Mantenha o alvo de calibração fixo e aguarde um seguimento estável antes de iniciar um novo conjunto. Rode e incline os óculos inteligentes suavemente; faça uma pausa antes de cada captura. + Capte pelo menos 24 visualizações variadas do alvo de calibração estacionário. + Rode os óculos inteligentes para a esquerda e para a direita e incline-os para cima e para baixo; o movimento sem rotação não pode calibrar o alinhamento da câmara. + Linha de base da câmara implausível + Mova a cabeça em orientações mais variadas. + Rotação câmara-cabeça inválida + O alinhamento da câmara com a cabeça é inconsistente. + A calibração não pôde ser concluída. %1$s As suas visualizações capturadas são guardadas. + Erro de reprojeção retido %1$.2f px excede 2 px. Recalibrar. + %1$d / 24 cantos de tabuleiro de xadrez detetados em ambas as câmaras. Mantenha o alvo de calibração completo visível e permaneça imóvel. Se já estiver visível, seleccione 12 pol. ou 30 cm e meça a distância mais próxima antes de tentar novamente. + O alvo de calibração está visível, mas a sua profundidade não pôde ser medida de forma fiável. Segure os óculos inteligentes e mantenha o alvo de calibração plano e bem iluminado e tente novamente. + A medição da câmara era inválida. Fique imóvel e tente novamente. + Verificação de distância aprovada. + Verifique novamente a distância da câmara esquerda ao centro do alvo de calibração e tente novamente. + Câmaras medidas %1$s; distância selecionada %2$s. %3$s + Aguarde pelas visualizações de ambas as câmaras antes de iniciar a calibração. + As visualizações guardadas podem ser recalculadas. Inicie uma nova calibração para captar no sistema de coordenadas de seguimento atual. + Incompatibilidade de checksum do modelo de mãos + O OpenCV não conseguiu carregar + Olhe em redor lentamente num ambiente bem iluminado.\nMantenha as câmaras de seguimento desobstruídas e viradas para móveis ou outros detalhes visíveis. diff --git a/app/src/main/res/values-pt/strings.xml b/app/src/main/res/values-pt/strings.xml index a7463002cd..0dc9d0e576 100644 --- a/app/src/main/res/values-pt/strings.xml +++ b/app/src/main/res/values-pt/strings.xml @@ -2377,14 +2377,14 @@ Tela Taxa de atualização 3D (lado a lado) - Cada olho recebe a própria metade de uma imagem de 3840×1080. Se a imagem sumir, mantenha pressionado o botão 2D/3D dos óculos. + Alterne os óculos inteligentes para 3D lado a lado. O rastreamento da cabeça é controlado separadamente. O sinal 3D não foi confirmado. Tente novamente quando a imagem 2D voltar. Sem imagem: os óculos estão em um modo que este celular não consegue enviar. Mantenha pressionado o botão 2D/3D deles ou desconecte e reconecte os óculos. Taxa de atualização em 3D 3D para jogos de RV Muda para 3D enquanto o SteamVR está em execução e volta depois. - Imagem 3D - Automático: o SteamVR preenche a visão; outros jogos flutuam como uma tela em 3D e ficam planos em 2D. + Imagem + O modo automático exibe conteúdo plano em ambos os olhos e detecta o SteamVR. Selecione Jogo lado a lado para conteúdo SBS. Automático Tela virtual Jogo lado a lado @@ -2394,20 +2394,20 @@ Estas configurações valem enquanto Jogo nos óculos estiver ativado e o jogo for exibido neles. O modo Automático mantém este jogo 2D em tela cheia. Use uma tela virtual para ajustar a largura, a distância e o rastreamento da cabeça. Usar tela virtual - O SteamVR preenche a visão. Ajuste o campo de visão abaixo; a largura e a distância valem só para uma tela virtual. + O SteamVR preenche a visualização. Ajuste seu campo de visão em VR; a largura e a distância se aplicam somente a uma tela virtual. Jogos lado a lado preenchem a visão de cada olho. A largura e a distância valem só para uma tela virtual. O modo Automático mantém este jogo 2D fixo na visão. Escolha Tela virtual na seção Tela para usar o rastreamento da cabeça. O rastreamento da cabeça vale para uma tela virtual ou um jogo do SteamVR em execução. - Óculos + Dispositivo Brilho Volume Escurecimento Escurece as lentes frontais. - Rastreamento da cabeça + Rastreamento Rastreamento da cabeça Os sensores dos próprios óculos giram a tela virtual e o SteamVR com a sua cabeça. Recentralizar visão - Recentralizar + Recentralizar tela Campo de visão do SteamVR Menor aproxima o SteamVR e preenche os óculos; maior mostra mais ao seu redor. Jogando em %1$s @@ -2428,8 +2428,8 @@ Remover a calibração salva e restaurar o padrão do modelo? Recentralize depois de colocar os óculos de novo. Redefinir Rastreamento das mãos - Rastrear suas mãos com a câmera? - A câmera consegue ver suas mãos. Sem nenhum controle conectado, suas mãos livres viram as mãos de RV: junte o polegar e o indicador para clicar, feche a mão para pegar e, para abrir o menu, vire a palma para você e junte os dedos. Com Joy-Cons, ela os coloca onde suas mãos realmente estão. As imagens são processadas neste dispositivo e nunca são salvas ou enviadas. + Rastrear mãos ou controles Joy-Con com a câmera do celular? + Sem nenhum controle conectado, a câmera do celular rastreia suas mãos nuas em VR: junte o polegar e o indicador para clicar, feche a mão para pegar e vire a palma da mão em sua direção e junte para abrir o menu. Com controles Joy-Con emparelhados, a câmera rastreia a posição deles enquanto os controles Joy-Con fornecem rotação e entradas de botão. As imagens são processadas neste dispositivo e nunca são salvas ou enviadas. Câmera traseira Recomendada. Costuma ser mais nítida e ampla. Câmera frontal @@ -2437,7 +2437,7 @@ Usar câmera Agora não Rastreamento das mãos pela câmera - Sem nenhum controle conectado, suas mãos viram as mãos de RV: junte os dedos para clicar e, com a palma virada para você, junte-os para abrir o menu. Com Joy-Cons, ela os coloca onde a câmera os vê. As imagens ficam neste dispositivo. + Use a câmera do telefone para gestos com as mãos nuas ou para posicionar os controles Joy-Con emparelhados em VR. Os controles Joy-Con fornecem rotação e comandos dos botões. Pausa enquanto os óculos inteligentes rastreiam suas mãos ou controles Joy-Con. As imagens são processadas apenas neste dispositivo. Câmera Acesso à câmera Permita o acesso à câmera para que o rastreamento das mãos possa começar. @@ -2705,4 +2705,208 @@ Convertendo %1$s para o Steam. Mantenha o DroidDeck aberto. Este aparelho não consegue decodificar esse vídeo. Não foi possível importar esse vídeo + Câmeras Luma Ultra — Experimental + Rastreamento de posição do Joy-Con + Use as câmeras dos óculos inteligentes para posicionar seus controles Joy-Con emparelhados. A rotação e os comandos dos botões vêm dos controles Joy-Con. A posição é estimada quando seus pulsos estão escondidos. Substitui os controles operados com as mãos nuas e pausa o rastreamento da câmera do telefone. Aponte os controles Joy-Con para frente ao conectar ou redefinir o centro de rastreamento. + Ative o rastreamento de posição primeiro. Requer controles Joy-Con com sensor de movimento no Android 12 ou posterior. Desativado por padrão. + Óculos inteligentes + As configurações de exibição e rastreamento de cabeça são compartilhadas entre os menus do DroidDeck, jogos e sessões da área de trabalho. + Conecte os óculos inteligentes para alterar suas configurações de exibição e rastreamento. Suas configurações salvas são mantidas ao desconectar. + VR + Modo de exibição + Saída 2D + Saída 3D + Imagem e tela virtual + Posição e nível do piso + Rastreamento de mãos — Experimental + Status do rastreamento + Resolução 2D + Resolução 3D + Resolução VR + Automático + Igual a 2D/3D + Resolução de saída por olho. + Ative o recurso \"Jogar em óculos inteligentes\" para selecionar o modo nativo de 30 Hz da tela. + Tela virtual 3DoF + Ancore jogos planos à sua frente para que você possa olhar ao redor. Ativa o recurso \"Jogar em óculos inteligentes\" sem alternar para 3D. + A largura e a distância atualizam a tela virtual rastreada para menus, jogos e sessões de desktop do DroidDeck imediatamente. + O rastreamento posicional inclui a rotação da cabeça no SteamVR. Para rastreamento somente de rotação, desative o rastreamento posicional. + Controla o movimento da cabeça na tela virtual. O rastreamento posicional inclui a rotação da cabeça no SteamVR. + Ações rápidas + Olhe para onde você quer que a tela fique e, em seguida, redefina o centro de rastreamento para definir sua altura e direção. + Recentralizar Joy-Con + Câmera do celular — Experimental + Rastrear mãos ou controles Joy-Con + Tela virtual 6DoF + Rastreamento posicional — experimental + Movimento físico em VR e ao redor de telas virtuais. Reiniciar o rastreamento leva um instante. + Altura atual dos olhos em relação ao chão + Definir nível do chão a partir da altura atual + Definir nível do chão + Configuração e diagnóstico da câmera estéreo + Verifique a calibração da câmera e o rastreamento das mãos antes de jogar. + Abrir configuração + Controladores operados com as mãos nuas + Use as câmeras dos óculos inteligentes para mirar com as mãos, faça o gesto de pinça para clicar e feche a mão para agarrar em VR. Os joysticks do gamepad se movem e giram. Substitui o rastreamento de posição do Joy-Con. Pode haver atraso ou perda de rastreamento durante os jogos. + Ative os controladores operados com as mãos nuas sob as câmeras Luma Ultra em Rastreamento. Mostre as mãos abertas primeiro. + Calibração compartilhada do Luma Ultra + Usando a base compartilhada do Luma Ultra. Calibre seus próprios óculos inteligentes para verificar a precisão deles. + Calibração medida verificada + Validação necessária + Controladores operados com as mãos nuas ficam disponíveis após a verificação da distância medida ser aprovada. + Rastreamento perdido + Ainda preso? No seu telefone: óculos inteligentes → Rastreamento → Abrir configuração → Mostrar diagnóstico → Reiniciar rastreamento. + Óculos inteligentes desconectados + Verifique a conexão USB e reconecte os óculos inteligentes.\nAceite a solicitação de acesso USB no seu telefone, se ela aparecer. + Uma vez conectado, olhe lentamente ao redor em uma sala bem iluminada para restaurar o rastreamento. + É necessário recentralizar + O rastreamento retornou em uma nova posição.\nOlhe para frente e toque em redefinir centro de rastreamento no seu telefone. + Você também pode encontrar a opção de redefinir o centro de rastreamento em óculos inteligentes → Rastreamento → Abrir configuração. Sua calibração de câmera salva será mantida. + Fique parado por um momento + A redefinição do centro de rastreamento está em andamento.\nMantenha os óculos inteligentes firmes enquanto o rastreamento se estabiliza. + Esta tela fecha automaticamente quando o rastreamento da cabeça está pronto. + Mira estabilizada com as mãos + Mire do ombro até a palma da mão. Desligue para rotação controlada pelo pulso. + Configuração espacial + Aguardando rastreamento… + Câmeras de rastreamento esquerda e direita + Sincronização de câmera + Pronto + Aguardando o alinhamento da câmera e do rastreamento da cabeça. Mantenha os óculos inteligentes conectados. + 1. Preparar o alvo de calibração + Imprimir em tamanho real + Cada quadrado deverá medir 30 mm (1.181 in). Monte a folha plana sobre uma superfície rígida em uma área bem iluminada. + Imprimir padrão de calibração + 2. Capturar diferentes visualizações + Mantenha o alvo de calibração estacionário + Aproxime, afaste e lateralmente os óculos inteligentes. Vire-os para a esquerda/direita, incline-os para cima/para baixo e incline-os lateralmente. Mantenha o alvo de calibração em ambas as câmeras e faça uma breve pausa antes de cada captura. + Iniciar nova calibração + Aguardando sincronização da câmera. + Iniciar uma nova calibração para coletar visualizações. + Mantenha o alvo de calibração visível em ambas as visualizações. Capture pelo menos 24 visualizações nítidas de diferentes ângulos. + Capturando… + Capturar visualização do alvo de calibração + Calcular alinhamento da câmera + Calculando… + Calcular calibração + 3. Verifique a distância + Distância medida + Comece com 12 polegadas ou 30 cm para que os marcadores impressos sejam mais fáceis de detectar. Escolha a medida exata que você usará. + Câmera esquerda para o centro do alvo de calibração + Verificando distância… + Validar distância + Diagnóstico + Mostrar diagnóstico + Ferramentas de temporização e recuperação de rastreamento da câmera. + Tempo da câmera + Entrada do rastreamento de mãos + Aguardando o tempo da câmera. + Imagens da câmera + Detecção de mãos por GPU + CPU é o padrão. A GPU é experimental e pode fazer com que o SteamVR reinicie. Esta escolha é redefinida quando o rastreamento é reiniciado. + Detecção Lite de modelos de mãos + Use o detector de palma Lite e os pontos-chave Lite nas mãos. Verifique a mira, aperte e agarre a precisão. Redefine quando o rastreamento é reiniciado. + Frequência de entrada automática para rastreamento de mãos + Ajuste a entrada à velocidade de processamento. Redefine quando o rastreamento é reiniciado. + Limitar a frequência de entrada para rastreamento de mãos + Use metade das imagens da câmera. Desligue para comparar a frequência máxima. Redefine quando o rastreamento é reiniciado. + Captura de diagnóstico + Salve localmente um par de imagens estéreo. As imagens são salvas somente quando solicitadas. + Salvar imagem da câmera + Reiniciar rastreamento + Utilize se o rastreamento não for recuperado em uma área bem iluminada. Uma reinicialização requer uma nova origem de rastreamento. + Reiniciar + Reiniciar rastreamento? + As visualizações de calibração não salvas serão perdidas. Mantenha os óculos inteligentes imóveis posteriormente e redefina o centro de rastreamento quando o rastreamento for restaurado. + %1$d / 24 visualizações capturadas + Captura pausada: %1$s + Medida %1$s. Mostre o alvo de calibração completo em ambas as visualizações e fique imóvel. + %1$.1f Hz • idade da imagem %2$.1f ms • processamento %3$.1f ms + Limite de entrada %1$.1f Hz • %2$.0f%% de imagens da câmera. O rastreamento da cabeça continua em sua frequência máxima. + %1$d processado • %2$d descartado • %3$d ignorado pelo limite de entrada + DroidDeck ChArUco 30 mm + DroidDeck - Calibração Luma Ultra + Imprimir em 100%/tamanho real. Cada quadrado: 30 mm (1,181 pol.). + Mantenha o alvo de calibração plano e estacionário; mova os óculos inteligentes entre as capturas. + Verificação de escala: 100 mm (3,937 pol.) entre marcas + 30,48 cm (12 pol.) + 30 cm (11,81 pol.) + 50,8 cm (20 pol.) + 50 cm (19,69 pol.) + Desativado + Aguardando rastreamento estável + Desconectado + Os controladores operados com as mãos nuas estão desligados + O rastreamento posicional está desativado ou os óculos inteligentes estão desconectados + Redefinição do centro de rastreamento solicitada — mantenha os óculos imóveis enquanto o rastreamento se estabiliza. + Rastreamento perdido — enfrente uma área bem iluminada com detalhes visíveis + Origem do rastreamento alterada — toque em redefinir o centro de rastreamento e mantenha os óculos imóveis. + 6DoF ativo + Conecte o Luma Ultra e ative o rastreamento posicional. + Calibração verificada para esta conexão. + Calibração verificada e salva. + Esperando por câmeras estéreo + Aguardando rastreamento de mãos + Mantenha o alvo de calibração 5 × 7 estacionário. Capture mais de 24 visualizações enquanto move e gira os óculos inteligentes. + Aguardando a próxima imagem da câmera. Segure os óculos inteligentes imóveis. + Verificando a próxima imagem da câmera. Mantenha o alvo de calibração completo visível e permaneça imóvel. + Inicie a calibração primeiro + Nenhuma imagem nova da câmera chegou. Verifique a conexão dos óculos inteligentes e as visualizações da câmera e tente novamente. + Reinicialização do relógio da câmera + Sistema de coordenadas de rastreamento alterado. Suas visualizações foram salvas para recálculo. Redefina o centro de rastreamento e inicie um novo conjunto para capturar mais visualizações. + calibração do dispositivo carregada + Calibração básica do Luma Ultra carregada + calibração necessária + Toque em Iniciar nova calibração primeiro. + A redefinição do centro de rastreamento está aguardando um rastreamento estável. Mantenha os óculos imóveis por um momento. + Rastreamento alterado. Toque em redefinir o centro de rastreamento uma vez e mantenha os óculos imóveis antes de capturar. + Captura rejeitada: o rastreamento da cabeça estava fora de sincronia ou mudou durante a captura. Fique parado e tente novamente. + Calcule o alinhamento da câmera antes de verificar a distância. + falha no processamento da câmera + Rastreamento da cabeça alterado durante a detecção de mãos + Aguardando sincronização da câmera e da cabeça + Nenhum pulso detectado. Mantenha as alças do controlador Joy-Con na frente dos óculos inteligentes + Nenhuma mão detectada. Mostre as palmas das mãos abertas na frente dos óculos inteligentes + Pulsos visíveis em apenas uma câmera; mantenha as alças do controle na visualização compartilhada + Mãos visíveis em apenas uma câmera; mantenha as duas palmas na visualização compartilhada + Ambas as câmeras veem mãos, mas a correspondência esquerda/direita é ambígua + Mãos detectadas, mas a profundidade estéreo é inconsistente + Posição do pulso rejeitada por verificações de estéreo ou de movimento + Pontos estéreo detectados, mas a geometria da palma é inconsistente + Conclua a calibração e a verificação de distância para ativar o rastreamento de mãos + Aguardando rastreamento de cabeça estável; redefina o centro de rastreamento se solicitado. + A observação da câmera é muito antiga; esperando por um novo par + Ajustar %1$.2f px. Meça a distância selecionada da câmera esquerda até o centro do alvo de calibração e valide. + OpenCV indisponível: %1$s + %1$d visualizações salvas restauradas. Calcule a calibração para tentar novamente ou inicie um novo conjunto para capturar mais. + Capturado %1$d/24 visualizações. Mantenha o alvo de calibração fixo; mova os óculos inteligentes para a próxima visualização. + Captura rejeitada: %1$d/12 cantos necessários visíveis em ambas as câmeras. Mostre mais do alvo de calibração, fique imóvel e tente novamente. + A verificação de distância não pôde ser concluída: %1$s. Tente novamente. + Detecção de mãos indisponível: %1$s. Troque a CPU/GPU ou alterne os controladores operados com as mãos nuas para tentar novamente. + A detecção de mãos excedeu %1$d ms; observação descartada + %1$d / 2 posições de pulso do Joy-Con medidas por estéreo + Palmas rastreadas: %1$d / 2; gesto de pinça pronto: %2$d; gesto de agarrar pronto: %3$d + Captura de diagnóstico salva em %1$s + Rastreamento de mãos interrompido: %1$s + Estéreo %1$d×%2$d; %3$s + O rastreamento da cabeça e o alvo de calibração discordam em %1$s (limite de 5 cm/2 pol.). Mantenha o alvo de calibração fixo e aguarde um rastreamento estável antes de iniciar um novo conjunto. Gire e incline os óculos inteligentes suavemente; faça uma pausa antes de cada captura. + Capture pelo menos 24 visualizações variadas do alvo de calibração estacionário. + Gire os óculos inteligentes para a esquerda e para a direita e incline-os para cima e para baixo; o movimento sem rotação não pode calibrar o alinhamento da câmera. + Linha de base da câmera implausível + Mova sua cabeça em orientações mais variadas. + Rotação câmera-cabeça inválida + O alinhamento da câmera com a cabeça é inconsistente. + A calibração não pôde ser concluída. %1$s Suas visualizações capturadas são salvas. + Erro de reprojeção retido %1$.2f px excede 2 px. Recalibrar. + %1$d / 24 cantos de tabuleiro de xadrez detectados em ambas as câmeras. Mantenha o alvo de calibração completo visível e permaneça imóvel. Se já estiver visível, selecione 12 pol. ou 30 cm e meça a distância mais próxima antes de tentar novamente. + O alvo de calibração está visível, mas sua profundidade não pôde ser medida de forma confiável. Segure os óculos inteligentes e mantenha o alvo de calibração plano e bem iluminado e tente novamente. + A medição da câmera era inválida. Fique parado e tente novamente. + Verificação de distância aprovada. + Verifique novamente a distância da câmera esquerda até o centro do alvo de calibração e tente novamente. + Câmeras medidas %1$s; distância selecionada %2$s. %3$s + Aguarde as visualizações de ambas as câmeras antes de iniciar a calibração. + As visualizações salvas podem ser recalculadas. Inicie uma nova calibração para capturar no sistema de coordenadas de rastreamento atual. + Incompatibilidade de soma de verificação do modelo de mãos + OpenCV não pôde carregar + Olhe ao redor lentamente em um ambiente bem iluminado.\nMantenha as câmeras de rastreamento desobstruídas e voltadas para móveis ou outros detalhes visíveis. diff --git a/app/src/main/res/values-ro/strings.xml b/app/src/main/res/values-ro/strings.xml index 4bfcb9fa9e..d1ea591791 100644 --- a/app/src/main/res/values-ro/strings.xml +++ b/app/src/main/res/values-ro/strings.xml @@ -2391,14 +2391,14 @@ Afișaj Rată de reîmprospătare 3D (alăturat) - Fiecare ochi primește propria jumătate dintr-o imagine de 3840×1080. Dacă imaginea dispare, ține apăsat butonul 2D/3D al ochelarilor. + Comută ochelarii inteligenți la 3D alăturat. Urmărirea capului este controlată separat. Semnalul 3D nu a fost confirmat. Încearcă din nou când revine imaginea 2D. Nicio imagine: ochelarii sunt într-un mod pe care acest telefon nu îl poate trimite. Ține apăsat butonul lor 2D/3D sau deconectează-i și reconectează-i. Rată de reîmprospătare 3D 3D pentru jocuri VR Trece la 3D cât timp rulează SteamVR, apoi revine. - Imagine 3D - Automat: SteamVR umple vederea; celelalte jocuri plutesc ca un ecran în 3D și rămân plate în 2D. + Imagine + Afișează automat conținut plat în ambii ochi și detectează SteamVR. Alege Joc alăturat pentru conținutul SBS. Automat Ecran virtual Joc alăturat @@ -2408,20 +2408,20 @@ Aceste setări se aplică cât timp Joc pe ochelari este activat și jocul este afișat acolo. Modul Automat păstrează acest joc 2D pe tot ecranul. Folosește un ecran virtual pentru a-i ajusta lățimea, distanța și urmărirea capului. Folosește ecranul virtual - SteamVR umple vederea. Ajustează-i câmpul vizual mai jos; lățimea și distanța se aplică doar unui ecran virtual. + SteamVR umple vizualizarea. Ajustează câmpul său vizual în VR; lățimea și distanța se aplică numai unui ecran virtual. Jocurile alăturate umplu vederea fiecărui ochi. Lățimea și distanța se aplică doar unui ecran virtual. Modul Automat menține acest joc 2D fix în câmpul vizual. Alege Ecran virtual în Afișaj pentru a folosi urmărirea capului. Urmărirea capului se aplică unui ecran virtual sau unui joc SteamVR care rulează. - Ochelari + Dispozitiv Luminozitate Volum Întunecare Întunecă lentilele din față. - Urmărirea capului + Urmărire Urmărirea capului Senzorii proprii ai ochelarilor rotesc ecranul virtual și SteamVR odată cu capul tău. Recentrează vederea - Recentrează + Recentrează ecranul Câmp vizual SteamVR Mai mic aduce SteamVR mai aproape și umple ochelarii; mai mare arată mai mult din jurul tău. Se joacă pe %1$s @@ -2442,8 +2442,8 @@ Elimini calibrarea salvată și restaurezi valorile implicite ale modelului? Recentrează după ce îți pui ochelarii la loc. Resetează Urmărirea mâinilor - Urmărești mâinile cu camera? - Camera îți poate vedea mâinile. Când nu e conectat niciun controller, mâinile tale goale devin mâinile VR: apropie degetul mare de arătător ca să dai clic, strânge mâna ca să apuci, iar pentru meniu întoarce palma spre tine și apropie degetele. Cu Joy-Con, îi așază acolo unde sunt de fapt mâinile tale. Imaginile sunt procesate pe acest dispozitiv și nu sunt niciodată salvate sau trimise. + Urmărește mâinile sau controlerele Joy-Con cu camera telefonului? + Fără niciun controler conectat, camera telefonului urmărește mâinile goale în VR: ciupește degetul mare și arătător pentru a face clic, închide mâna pentru a prinde și întoarce palma spre tine și ciupește pentru a deschide meniul. Cu controlerele Joy-Con asociate, camera urmărește poziția lor, în timp ce controlerele Joy-Con oferă intrări de rotație și butoane. Imaginile sunt procesate pe acest dispozitiv și nu sunt niciodată salvate sau trimise. Camera din spate Recomandat. De obicei mai clară și mai largă. Camera frontală @@ -2451,7 +2451,7 @@ Folosește camera Nu acum Urmărirea mâinilor cu camera - Când nu e conectat niciun controller, mâinile tale devin mâinile VR: apropie degetele ca să dai clic, iar cu palma spre tine apropie-le pentru meniu. Cu Joy-Con, îi așază acolo unde îi vede camera. Imaginile rămân pe acest dispozitiv. + Folosește camera telefonului pentru gesturi cu mâinile goale sau pentru a poziționa controlerele Joy-Con asociate în VR. Controlerele Joy-Con oferă comenzi de rotație și comenzi de butoane. Pune pauză în timp ce ochelarii inteligenți urmăresc mâinile sau controlerele Joy-Con. Imaginile sunt procesate numai pe acest dispozitiv. Camera Acces la cameră Permite accesul la cameră pentru a putea începe urmărirea mâinilor. @@ -2714,4 +2714,208 @@ Se convertește %1$s pentru Steam. Lasă DroidDeck deschis. Acest dispozitiv nu poate decoda videoclipul. Videoclipul nu a putut fi importat + Camere Luma Ultra — Experimentale + Urmărirea poziției Joy-Con + Folosește camerele ochelarilor inteligenți pentru a poziționa controlerele Joy-Con asociate. Rotirea și comenzile de butoane provin de la controlerele Joy-Con. Poziția este estimată atunci când încheieturile mâinilor sunt ascunse. Înlocuiește controlerele acționate cu mâinile goale și întrerupe urmărirea camerei telefonului. Îndreaptă controlerele Joy-Con înainte atunci când conectezi sau resetezi centrul de urmărire. + Activează mai întâi urmărirea pozițională. Necesită controlere Joy-Con cu funcție de mișcare pe Android 12 sau o versiune ulterioară. Dezactivat în mod implicit. + Ochelari inteligenți + Setările de afișare și urmărire a capului sunt partajate între meniurile, jocurile și sesiunile desktop DroidDeck. + Conectează ochelarii inteligenți pentru a modifica setările de afișare și urmărire. Setările salvate sunt păstrate atunci când te deconectezi. + VR + Mod de afișare + Ieșire 2D + Ieșire 3D + Imagine și ecran virtual + Poziție și nivelul podelei + Urmărirea mâinilor — Experimental + Stare urmărire + Rezoluție 2D + Rezoluție 3D + Rezoluție VR + Automat + La fel ca 2D / 3D + Rezoluție de ieșire per ochi. + Activează Joc pe ochelari pentru a selecta modul nativ de 30 Hz al afișajului. + Ecran virtual 3DoF + Ancorează jocurile 2D în fața ta, astfel încât să poți privi în jur. Activează Joc pe ochelari fără a comuta la 3D. + Lățimea și distanța actualizează imediat ecranul virtual urmărit pentru meniurile, jocurile și sesiunile desktop DroidDeck. + Urmărirea pozițională include rotirea capului în SteamVR. Pentru urmărirea doar prin rotație, dezactivează urmărirea pozițională. + Controlează mișcarea capului pe ecranul virtual. Urmărirea pozițională include rotirea capului în SteamVR. + Acțiuni rapide + Privește unde dorești ecranul, apoi resetează centrul de urmărire pentru a-i seta înălțimea și direcția. + Recentrează Joy-Con + Camera telefonului — Experimental + Urmărește mâinile sau controlerele Joy-Con + Ecran virtual 6DoF + Urmărirea pozițională — experimental + Mișcarea fizică în VR și în jurul ecranelor virtuale. Repornirea urmăririi durează un moment. + Înălțimea curentă a ochilor deasupra podelei + Setează nivelul podelei de la înălțimea curentă + Setează nivelul podelei + Configurarea și diagnosticarea camerei stereo + Verifică calibrarea camerei și urmărirea mâinilor înainte de a juca. + Deschide configurarea + Controlere acționate cu mâinile goale + Folosește camerele ochelarilor inteligenți pentru a ținti cu mâinile, ciupește pentru a face clic și închide mâna pentru a prinde în VR. Manetele gamepad-ului se mișcă și se rotesc. Înlocuiește urmărirea poziției Joy-Con. Urmărirea poate avea întârziere sau poate fi pierdută în timpul jocurilor. + Activează controlerele acționate cu mâinile goale sub camerele Luma Ultra în Urmărire. Afișează mai întâi mâinile deschise. + Calibrare Luma Ultra partajată + Folosește calibrarea Luma Ultra partajată. Calibrează-ți propriii ochelari inteligenți pentru a verifica precizia. + Calibrare măsurată verificată + Validare necesară + Controlerele acționate cu mâinile goale devin disponibile după trecerea verificării distanței măsurate. + Urmărire pierdută + Privește încet în jur într-o cameră bine luminată.\nNu acoperi camerele de urmărire și privește spre mobilier sau alte detalii vizibile. + Încă blocat? Pe telefon: Ochelari inteligenți → Urmărire → Deschide configurarea → Afișează diagnostice → Repornește urmărirea. + Ochelari inteligenți deconectați + Verifică conexiunea USB și reconectează ochelarii inteligenți.\nAcceptă solicitarea de acces USB de pe telefon dacă apare. + După conectare, privește încet în jur într-o cameră bine luminată pentru a restabili urmărirea. + Este necesară recentrarea + Urmărirea a revenit într-o nouă poziție.\nPrivește înainte, apoi atinge „Recentrează” pe telefon. + Găsești opțiunea „Recentrează” și în Ochelari inteligenți → Urmărire → Deschide configurarea. Calibrarea salvată a camerei este păstrată. + Stai nemișcat pentru o clipă + Recentrarea este în curs.\nȚine ochelarii inteligenți nemișcați în timp ce urmărirea se stabilizează. + Acest ecran se închide automat când urmărirea capului este gata. + Țintirea stabilizată cu mâinile + Țintește de la umăr prin palmă. Dezactivează această opțiune pentru rotație controlată de încheietura mâinii. + Configurare spațială + Se așteaptă urmărirea... + Camere de urmărire stânga și dreapta + Sincronizarea camerei + Gata + Se așteaptă ca camera și urmărirea capului să se alinieze. Păstrează ochelarii inteligenți conectați. + 1. Pregătește ținta de calibrare + Imprimă la dimensiunea reală + Fiecare pătrat trebuie să măsoare 30 mm (1,181 inchi). Montează foaia plat pe o suprafață rigidă într-o zonă bine luminată. + Tipărește modelul de calibrare + 2. Capturează vederi diferite + Păstrează ținta de calibrare staționară + Mută ochelarii inteligenți mai aproape, mai departe și în lateral. Rotește-i la stânga/dreapta, înclină-i în sus/jos și înclină-i lateral. Păstrează ținta de calibrare vizibilă în ambele camere și fă o pauză scurtă înainte de fiecare captură. + Începe o nouă calibrare + Se așteaptă sincronizarea camerei. + Începe o nouă calibrare pentru a colecta vizualizări. + Păstrează ținta de calibrare vizibilă în ambele previzualizări. Capturează cel puțin 24 de vizualizări clare din unghiuri diferite. + Se captează... + Capturează vizualizarea țintei de calibrare + Calculează alinierea camerei + Se calculează... + Calculează calibrarea + 3. Verifică distanța + Distanța măsurată + Începe cu 12 in sau 30 cm, astfel încât markerii imprimați să fie mai ușor de detectat. Alege măsura exactă pe care o vei folosi. + Distanța de la camera din stânga la centrul țintei de calibrare + Se verifică distanța... + Validează distanța + Diagnosticare + Afișează diagnostice + Instrumente de sincronizare și urmărire a camerei. + Temporizarea camerei + Intrare din urmărirea mâinilor + Se așteaptă temporizarea camerei. + Imagini ale camerei + Detectarea mâinilor prin GPU + CPU este implicit. GPU-ul este experimental și poate determina repornirea SteamVR. Această alegere se resetează la repornirea urmăririi. + Detectarea mâinilor cu modele Lite + Folosește detectorul de palme Lite și modelul Lite pentru punctele de reper ale mâinii. Verifică precizia țintirii și a gesturilor de ciupire și prindere. Se resetează la repornirea urmăririi. + Frecvența de intrare automată pentru urmărirea mâinilor + Reglează intrarea la viteza de procesare. Se resetează la repornirea urmăririi. + Limitează frecvența de intrare pentru urmărirea mâinilor + Folosește jumătate din imaginile camerei. Dezactivează pentru a compara frecvența maximă. Se resetează la repornirea urmăririi. + Captură diagnostică + Salvează o pereche de imagini stereo local. Imaginile sunt salvate numai atunci când sunt solicitate. + Salvează imaginea camerei + Repornește urmărirea + Folosește dacă urmărirea nu se recuperează într-o zonă bine iluminată. O repornire necesită o nouă origine de urmărire. + Repornește + Repornește urmărirea? + Vizualizările de calibrare nesalvate se vor pierde. Menține ochelarii inteligenți nemișcați ulterior și resetează centrul de urmărire când urmărirea este restabilită. + %1$d / 24 de vizualizări capturate + Captură întreruptă: %1$s + Măsoară %1$s. Arată întreaga țintă de calibrare în ambele previzualizări, apoi ține ochelarii nemișcați. + %1$.1f Hz • vârsta imaginii %2$.1f ms • procesare %3$.1f ms + Limita de intrare %1$.1f Hz • %2$.0f%% a imaginilor camerei. Urmărirea capului continuă la frecvența maximă. + %1$d procesate • %2$d eliminate • %3$d omise de limita de intrare + DroidDeck ChArUco 30 mm + DroidDeck - calibrare Luma Ultra + Imprimă la 100%/Dimensiune reală. Fiecare pătrat: 30 mm (1,181 inchi). + Păstrează ținta de calibrare plată și staționară; mută ochelarii inteligenți între capturi. + Verificare scară: 100 mm (3,937 inchi) între repere + 12 inchi (30,48 cm) + 30 cm (11,81 inchi) + 20 inchi (50,8 cm) + 50 cm (19,69 inchi) + Dezactivat + Se așteaptă urmărirea stabilă + Deconectat + Controlerele operate cu mâinile goale sunt oprite + Urmărirea poziției este dezactivată sau ochelarii inteligenți sunt deconectați + Recentrare solicitată — ține ochelarii nemișcați în timp ce urmărirea se stabilizează + Urmărire pierdută — privește spre o zonă bine luminată, cu detalii vizibile + Originea urmăririi s-a schimbat — atinge „Recentrează”, apoi ține ochelarii nemișcați + 6DoF activ + Conectează Luma Ultra și activează urmărirea pozițională. + Calibrare verificată pentru această conexiune. + Calibrarea a fost verificată și salvată. + Se așteaptă camere stereo + Se așteaptă urmărirea mâinilor + Ține nemișcată ținta de calibrare 5 × 7. Capturează cel puțin 24 de vederi în timp ce miști și rotești ochelarii inteligenți. + Se așteaptă următoarea imagine a camerei. Ține ochelarii inteligenți nemișcați. + Se verifică următoarea imagine a camerei. Păstrează întreaga țintă de calibrare vizibilă și stai nemișcat. + Începe mai întâi calibrarea + Nu a sosit nicio imagine nouă a camerei. Verifică conexiunea ochelarilor inteligenți și previzualizările camerei, apoi încearcă din nou. + Resetarea ceasului camerei + Sistemul de coordonate al urmăririi s-a schimbat. Vederile capturate sunt salvate pentru recalculare. Recentrează, apoi începe un set nou pentru a captura mai multe vederi. + calibrarea dispozitivului a fost încărcată + Calibrarea bazei Luma Ultra a fost încărcată + este necesară calibrarea + Atinge mai întâi „Începe o nouă calibrare”. + Recentrarea așteaptă o urmărire stabilă. Ține ochelarii nemișcați pentru o clipă. + Urmărirea s-a schimbat. Atinge „Recentrează” o dată, apoi ține ochelarii nemișcați înainte de captură. + Captură respinsă: urmărirea capului nu era sincronizată sau s-a schimbat în timpul capturii. Stai nemișcat și încearcă din nou. + Calculează alinierea camerei înainte de a verifica distanța. + Procesarea camerei a eșuat + Urmărirea capului a fost schimbată în timpul detectării mâinilor + Se așteaptă sincronizarea camerei și a capului + Nu au fost detectate încheieturi. Păstrează mânerele controlerului Joy-Con în fața ochelarilor inteligenți + Nu au fost detectate mâini. Arată palmele deschise în fața ochelarilor inteligenți + Încheieturile sunt vizibile doar într-o cameră; ține mânerele controlerului în câmpul vizual comun + Mâinile sunt vizibile doar într-o cameră; ține ambele palme în câmpul vizual comun + Ambele camere văd mâini, dar potrivirea stânga/dreapta este ambiguă + Mâinile detectate, dar adâncimea stereo este inconsecventă + Poziția încheieturii mâinii a fost respinsă de verificări stereo sau de mișcare + Au fost detectate puncte stereo, dar geometria palmei este inconsecventă + Finalizează calibrarea și verificarea distanței pentru a activa mâinile + Se așteaptă o urmărire stabilă a capului; resetează centrul de urmărire dacă este solicitat + Observarea camerei este prea veche; așteptând o pereche proaspătă + Eroare de calibrare: %1$.2f px. Măsoară distanța selectată de la camera din stânga la centrul țintei de calibrare, apoi validează. + OpenCV indisponibil: %1$s + Au fost restaurate %1$d vederi salvate. Calculează calibrarea pentru a reîncerca sau începe un set nou pentru a captura mai multe. + Captură %1$d / 24 de vizualizări. Păstrează ținta de calibrare fixă; mută ochelarii inteligenți pentru următoarea vizualizare. + Captură respinsă: %1$d / 12 colțuri necesare sunt vizibile în ambele camere. Arată o porțiune mai mare din ținta de calibrare, stai nemișcat, apoi încearcă din nou. + Verificarea distanței nu s-a putut finaliza: %1$s. Încearcă din nou. + Detectarea mâinilor indisponibile: %1$s. Schimbă CPU/GPU sau comută controlerele operate cu mâinile goale pentru a reîncerca. + Detectarea mâinilor a depășit %1$d ms; observație eliminată + %1$d / 2 poziții ale încheieturii Joy-Con măsurate prin stereo + Palme urmărite: %1$d / 2; gest de ciupire pregătit: %2$d; gest de prindere pregătit: %3$d + Captură de diagnosticare salvată în %1$s + Urmărirea mâinilor oprită: %1$s + Stereo %1$d×%2$d; %3$s + Diferența dintre urmărirea capului și ținta de calibrare este de %1$s (limită 5 cm / 2 inchi). Păstrează ținta nemișcată și așteaptă stabilizarea urmăririi înainte de a începe un set nou. Rotește și înclină ușor ochelarii inteligenți; fă o pauză înainte de fiecare captură. + Capturează cel puțin 24 de vizualizări variate ale țintei staționare de calibrare. + Rotește ochelarii inteligenți la stânga și la dreapta și înclină-i în sus și în jos; mișcarea fără rotație nu poate calibra alinierea camerei. + Linia de bază a camerei neplauzibilă + Mișcă-ți capul prin orientări mai variate. + Rotire de la cameră la cap nevalidă + Alinierea camerei la cap este inconsecventă. + Calibrarea nu s-a putut finaliza. %1$s Vizualizările tale capturate sunt salvate. + Eroarea de reproiectare de validare de %1$.2f px depășește 2 px. Recalibrează. + %1$d / 24 de colțuri de șah detectate în ambele camere. Păstrează ținta completă de calibrare vizibilă și stai nemișcat. Dacă este deja vizibil, selectează 12 in sau 30 cm și măsoară distanța mai apropiată înainte de a reîncerca. + Ținta de calibrare este vizibilă, dar adâncimea sa nu a putut fi măsurată în mod fiabil. Ține nemișcați ochelarii inteligenți și menține ținta de calibrare plată și bine iluminată, apoi încearcă din nou. + Măsurarea camerei nu a fost validă. Stai nemișcat și încearcă din nou. + Verificarea distanței a reușit. + Verifică din nou distanța de la camera din stânga la centrul țintei de calibrare, apoi încearcă din nou. + Camere măsurate %1$s; distanța selectată %2$s. %3$s + Așteaptă ambele previzualizări ale camerei înainte de a începe calibrarea. + Vizualizările salvate pot fi recalculate. Începe o nouă calibrare pentru a captura în sistemul de coordonate de urmărire curent. + Nepotrivire a sumei de control a modelului de mâini + OpenCV nu s-a putut încărca diff --git a/app/src/main/res/values-ru/strings.xml b/app/src/main/res/values-ru/strings.xml index 901ffbc8d9..65db27eaf4 100644 --- a/app/src/main/res/values-ru/strings.xml +++ b/app/src/main/res/values-ru/strings.xml @@ -2410,14 +2410,14 @@ Экран Частота обновления 3D (стереопара) - Каждый глаз получает свою половину изображения 3840×1080. Если изображение пропадёт, удерживайте кнопку 2D/3D на очках. + Переключите умные очки в режим 3D «бок о бок». Отслеживание головы управляется отдельно. Сигнал 3D не подтверждён. Повторите попытку, когда вернётся изображение 2D. Нет изображения: очки в режиме, который этот телефон не может передать. Удерживайте их кнопку 2D/3D или отключите и снова подключите очки. Частота в 3D 3D для VR-игр Включает 3D, пока работает SteamVR, и возвращает обратно после. - Изображение 3D - Автоматически: SteamVR заполняет весь обзор; другие игры висят экраном в 3D и остаются плоскими в 2D. + Изображение + Автоматическое отображение плоского контента для обоих глаз и обнаружение SteamVR. Выберите игру «Рядом» для контента SBS. Автоматически Виртуальный экран Игра в стереопаре @@ -2427,20 +2427,20 @@ Эти настройки действуют, когда включена «Игра на очках» и игра показывается на них. В режиме «Автоматически» эта 2D-игра занимает весь экран. Чтобы настроить ширину, расстояние и отслеживание головы, используйте виртуальный экран. Использовать виртуальный экран - SteamVR заполняет весь обзор. Настройте поле зрения ниже; ширина и расстояние применяются только к виртуальному экрану. + SteamVR заполняет поле зрения. Настройте его поле зрения в VR; ширина и расстояние применяются только к виртуальному экрану. Игры в стереопаре заполняют обзор каждого глаза. Ширина и расстояние применяются только к виртуальному экрану. В режиме «Автоматически» эта 2D-игра неподвижна в поле зрения. Чтобы использовать отслеживание головы, выберите «Виртуальный экран» в разделе «Экран». Отслеживание головы работает с виртуальным экраном или запущенной игрой SteamVR. - Очки + Устройство Яркость Громкость Затемнение Затемняет передние линзы. - Отслеживание головы + Отслеживание Отслеживание головы Датчики очков поворачивают виртуальный экран и SteamVR вслед за головой. Сбросить вид - Центрировать + Центрировать экран заново Поле зрения SteamVR Меньше — SteamVR ближе и заполняет очки; больше — шире обзор вокруг. Игра на %1$s @@ -2461,8 +2461,8 @@ Удалить сохранённую калибровку и вернуть настройки модели по умолчанию? Снова надев очки, отцентрируйте вид. Сбросить Отслеживание рук - Отслеживать руки с помощью камеры? - Камера видит ваши руки. Если контроллер не подключён, ваши руки сами становятся руками в VR: сведите большой и указательный пальцы, чтобы нажать, сожмите кулак, чтобы схватить, а чтобы открыть меню, поверните ладонь к себе и сведите пальцы. С Joy-Con камера располагает их там, где на самом деле находятся ваши руки. Изображения обрабатываются на этом устройстве и никогда не сохраняются и не передаются. + Отслеживание рук или контроллеров Joy-Con с помощью камеры телефона? + Без подключенного контроллера камера телефона отслеживает ваши голые руки в VR: сожмите большой и указательный пальцы, чтобы нажать, сомкните руку, чтобы схватить, и поверните ладонь к себе, сжав пальцы, чтобы открыть меню. При подключенных контроллерах Joy-Con камера отслеживает их положение, в то время как контроллеры Joy-Con обеспечивают вращение и ввод с кнопок. Изображения обрабатываются на этом устройстве и никогда не сохраняются и не отправляются. Задняя камера Рекомендуется. Обычно резче и шире. Фронтальная камера @@ -2470,7 +2470,7 @@ Использовать камеру Не сейчас Отслеживание рук камерой - Если контроллер не подключён, ваши руки становятся руками в VR: сведите пальцы, чтобы нажать, а повернув ладонь к себе, — чтобы открыть меню. С Joy-Con располагает их там, где их видит камера. Изображения остаются на этом устройстве. + Используйте камеру телефона для жестов голыми руками или для позиционирования сопряженных контроллеров Joy-Con в VR. Контроллеры Joy-Con обеспечивают вращение и ввод с кнопок. Приостанавливается, пока умные очки отслеживают ваши руки или контроллеры Joy-Con. Изображения обрабатываются только на этом устройстве. Камера Доступ к камере Разрешите доступ к камере, чтобы начать отслеживание рук. @@ -2748,4 +2748,208 @@ %1$s преобразуется для Steam. Не закрывайте DroidDeck. Устройство не может декодировать это видео. Не удалось импортировать видео + Камеры Luma Ultra — Экспериментальная + Отслеживание положения Joy-Con + Используйте камеры умных очков для позиционирования сопряженных контроллеров Joy-Con. Вращение и ввод с кнопок осуществляются с помощью контроллеров Joy-Con. Положение оценивается, когда ваши запястья скрыты. Заменяет контроллеры, управляемые голыми руками, и приостанавливает отслеживание камерой телефона. Направьте контроллеры Joy-Con вперед при подключении или сбросе центра отслеживания. + Сначала включите отслеживание положения. Требуется контроллер Joy-Con с поддержкой движения на Android 12 или более поздней версии. По умолчанию отключено. + Умные очки + Настройки отображения и отслеживания положения головы используются совместно в меню DroidDeck, играх и сеансах рабочего стола. + Подключите умные очки, чтобы изменить их настройки отображения и отслеживания. Сохраненные настройки сохраняются при отключении. + VR + Режим отображения + Вывод 2D + Вывод 3D + Изображение и виртуальный экран + Положение и уровень пола + Отслеживание рук — экспериментальное + Статус отслеживания + Разрешение 2D + Разрешение 3D + Разрешение VR + Автоматическое + То же, что и 2D/3D + Разрешение вывода для каждого глаза. + Включите функцию «Игра на умных очках», чтобы выбрать собственный режим дисплея 30 Гц. + Виртуальный экран 3DoF + Закрепите плоские игры перед собой, чтобы вы могли осматриваться. Включает функцию «Игра на умных очках» без переключения в 3D. + Ширина и расстояние мгновенно обновляют отслеживаемый виртуальный экран для меню DroidDeck, игр и сеансов рабочего стола. + Позиционное отслеживание включает вращение головы в SteamVR. Для отслеживания только вращения отключите позиционное отслеживание. + Управляет движением головы на виртуальном экране. Позиционное отслеживание включает вращение головы в SteamVR. + Быстрые действия + Посмотрите туда, куда хотите направить экран, затем сбросьте центр отслеживания, чтобы установить его высоту и направление. + Центрировать Joy-Con заново + Камера телефона — экспериментальная функция + Отслеживание рук или контроллеров Joy-Con + Позиционное отслеживание — экспериментальное + Физическое движение в VR и вокруг виртуальных экранов. Перезапуск отслеживания занимает некоторое время. + Текущая высота глаз над полом + Установка уровня пола от текущей высоты + Установка уровня пола + Настройка и диагностика стереокамеры + Перед игрой проверьте калибровку камеры и отслеживание рук. + Открыть настройки + Управление контроллерами голыми руками + Используйте камеры умных очков для прицеливания руками, масштабируйте для щелчка и сжимайте руку для захвата в VR. Стики геймпада двигаются и поворачиваются. Заменяет отслеживание положения Joy-Con. Во время игр может наблюдаться задержка или потеря отслеживания. + Включить управление контроллерами голыми руками под камерами Luma Ultra в разделе «Отслеживание». Сначала отображать открытые руки. + Общая калибровка Luma Ultra + Использование общей базы Luma Ultra. Откалибруйте свои умные очки, чтобы проверить их точность. + Калибровка измерена и подтверждена + Требуется проверка + Контроллеры, управляемые голыми руками, становятся доступны после успешного прохождения проверки расстояния. + Отслеживание потеряно + Медленно осмотритесь в хорошо освещённой комнате.\nНе закрывайте камеры слежения и смотрите на мебель или другие хорошо различимые детали. + Все еще застряли? На телефоне: умные очки → Отслеживание → Открыть настройку → Показать диагностику → Перезапустить отслеживание. + Умные очки отключены + Проверьте USB-соединение и повторно подключите смарт-очки.\nПримите запрос на USB-доступ на телефоне, если он появится. + После подключения медленно осмотритесь в хорошо освещенной комнате, чтобы восстановить отслеживание. + Требуется повторное центрирование + Отслеживание вернулось в новое положение.\nПосмотрите вперед, затем нажмите «Сбросить центр отслеживания» на телефоне. + Вы также можете найти функцию сброса центра отслеживания в умных очках → Отслеживание → Открыть настройки. Сохраненная калибровка камеры сохранена. + Постой на мгновение неподвижно + Выполняется сброс центра отслеживания.\nДержите умные очки неподвижно, пока отслеживание не стабилизируется. + Этот экран закрывается автоматически, когда отслеживание положения головы готово. + Стабилизированное прицеливание руками + Цельтесь из плеча через ладонь. Выключите для вращения, управляемого запястьем. + Пространственная настройка + Ожидание отслеживания… + Левая и правая камеры слежения + Синхронизация камеры + Готово + Ожидание совмещения камеры и отслеживания головы. Держите умные очки подключенными. + 1. Подготовьте калибровочную мишень. + Печать в натуральную величину + Размер каждого квадрата должен составлять 30 мм (1,181 дюйма). Установите лист на твердую поверхность в хорошо освещенном месте. + Напечатать калибровочную мишень + 2. Снимайте разные виды + Держите калибровочную мишень неподвижной. + Перемещайте умные очки ближе, дальше и в стороны. Поверните их влево/вправо, наклоните вверх/вниз и наклоните в сторону. Сохраняйте калибровочную цель в обеих камерах и делайте небольшую паузу перед каждым захватом. + Начать новую калибровку + Ожидание синхронизации камеры. + Запустите новую калибровку для сбора представлений. + Сохраняйте видимость цели калибровки в обоих окнах предварительного просмотра. Сделайте как минимум 24 четких изображения под разными углами. + Захват… + Захват изображения цели калибровки + Вычисление выравнивания камеры + Вычисление… + Расчет калибровки + 3. Проверьте расстояние. + Измеренное расстояние + Начните с 12 дюймов или 30 см, чтобы напечатанные маркеры было легче обнаружить. Выберите точное измерение, которое вы будете использовать. + Левая камера к центру калибровочной цели + Проверка расстояния… + Проверка расстояния + Диагностика + Показать диагностику + Инструменты восстановления синхронизации и отслеживания камеры. + Синхронизация камеры + Ввод от отслеживания рук + Ожидание синхронизации камеры. + Изображения с камеры + Упрощенное обнаружение моделей рук + Используйте детектор ладоней Lite и ключевые точки Lite на руках. Проверьте точность прицеливания, захвата и захвата. Сбрасывается при перезапуске отслеживания. + Автоматический ввод частоты для отслеживания рук + Отрегулируйте ввод в соответствии со скоростью обработки. Сбрасывается при перезапуске отслеживания. + Ограничение входной частоты для отслеживания рук + Используйте половину изображений с камеры. Выключите, чтобы сравнить максимальную частоту. Сбрасывается при перезапуске отслеживания. + Диагностический захват + Сохраните одну пару стереоизображений локально. Изображения сохраняются только по запросу. + Сохранить изображение с камеры + Перезапустить отслеживание + Используйте, если слежение не восстанавливается в хорошо освещенном месте. Для перезапуска требуется новый источник отслеживания. + Перезапуск + Возобновить отслеживание? + Несохраненные калибровочные изображения будут потеряны. После этого держите умные очки неподвижно и сбросьте центр отслеживания, когда отслеживание восстановится. + %1$d / захвачено 24 просмотра + Захват приостановлен: %1$s + Измерение %1$s. Покажите полную калибровочную цель в обоих окнах предварительного просмотра, затем задержитесь. + %1$.1f Гц • возраст изображения %2$.1f мс • обработка %3$.1f мс + Предел ввода %1$.1f Гц • %2$.0f%% изображений с камеры. Отслеживание головы продолжается с максимальной частотой. + %1$d обработано • %2$d удалено • %3$d пропущено из-за ограничения ввода + DroidDeck ChArUco 30 mm + DroidDeck — калибровка Luma Ultra + Печать в размере 100% / Реальный размер. Каждый квадрат: 30 мм (1,181 дюйма). + Держите калибровочную мишень плоской и неподвижной; перемещайте умные очки между снимками. + Проверка шкалы: расстояние между делениями 100 мм (3,937 дюйма). + 12 дюймов (30,48 см) + 30 см (11,81 дюйма) + 20 дюймов (50,8 см) + 50 см (19,69 дюйма) + Отключено + Ожидание стабильного отслеживания + Отключено + Контроллеры, управляемые голыми руками, выключены. + Отслеживание положения выключено или умные очки отключены. + Запрошен сброс центра отслеживания — удерживайте неподвижно, пока отслеживание стабилизируется. + Слежение потеряно — смотрите в хорошо освещенное место с видимыми деталями. + Начало координат отслеживания изменено — нажмите «Сбросить центр отслеживания», затем удерживайте неподвижно. + 6DoF активна + Подключите Luma Ultra и включите отслеживание положения. + Калибровка для этого соединения проверена. + Калибровка проверена и сохранена. + Ожидание стереокамер + Ожидание отслеживания рук + Держите калибровочную мишень 5 × 7 неподвижно. Снимайте более 24 изображений, перемещая и вращая умные очки. + Ожидание следующего изображения с камеры. Держите умные очки неподвижно. + Проверка следующего изображения с камеры. Держите полную калибровочную цель видимой и держитесь неподвижно. + Сначала запустите калибровку + Свежее изображение с камеры не поступило. Проверьте подключение смарт-очков и предварительный просмотр камеры, затем повторите попытку. + Сброс часов камеры + Система координат отслеживания изменена. Ваши изображения сохранены для перерасчета. Сбросьте центр отслеживания, затем начните новый набор, чтобы получить больше изображений. + калибровка устройства загружена + Базовая калибровка Luma Ultra загружена. + требуется калибровка + Нажмите «Сначала начать новую калибровку». + Сброс центра отслеживания ожидает стабилизации отслеживания. Удерживайте неподвижно некоторое время. + Отслеживание изменилось. Нажмите один раз, чтобы сбросить центр отслеживания, затем удерживайте неподвижно перед захватом. + Снимок отклонён: отслеживание головы не было синхронизировано либо изменилось во время съёмки. Не двигайтесь и попробуйте снова. + Перед проверкой расстояния рассчитайте выравнивание камеры. + ошибка обработки камеры + Изменено отслеживание головы при обнаружении рук. + Ожидание синхронизации камеры и головы. + Запястья не обнаружены. Держите ручки контроллера Joy-Con перед умными очками. + Руки не обнаружены. Покажите раскрытые ладони перед умными очками + Запястья видны только на одной камере; держите дескрипторы вашего контроллера в общем представлении + Руки видны только на одной камере; держите обе ладони на виду + Обе камеры видят руки, но соответствие левого и правого неоднозначно. + Руки обнаружены, но глубина стерео непостоянна. + Положение запястья отклонено проверками стерео или движения. + Обнаружены стереоточки, но геометрия ладони противоречива. + Завершите калибровку и проверку расстояния, чтобы включить руки. + Ожидание стабильного отслеживания головы; сбросьте центр отслеживания, если потребуется. + Камера наблюдения устарела; жду новую пару + По размеру %1$.2f пикселей. Измерьте выбранное расстояние от левой камеры до центра калибровочной цели, а затем подтвердите. + OpenCV недоступен: %1$s + %1$d сохраненные просмотры восстановлены. Рассчитайте калибровку, чтобы повторить попытку, или начните новую настройку, чтобы захватить больше. + Снято %1$d / 24 просмотра. Держите цель калибровки фиксированной; переместите умные очки для следующего просмотра. + Захват отклонен: %1$d / 12 требуемых углов видны в обеих камерах. Покажите больше калибровочной цели, задержитесь и повторите попытку. + Не удалось завершить дистанционную проверку: %1$s. Попробуйте еще раз. + Обнаружение рук превысило %1$d мс; наблюдение отклонено + %1$d / 2 положения запястья Joy-Con, измеренные с помощью стереосистемы. + Отслеживаемые ладони: %1$d / 2; готовность к щипку: %2$d; готовность к захвату: %3$d + Диагностический захват сохранен в %1$s. + Отслеживание рук остановлено: %1$s + Стерео %1$d×%2$d; %3$s + Отслеживание положения головы и цель калибровки расходятся на %1$s (предел 5 см / 2 дюйма). Держите цель калибровки фиксированной и дождитесь устойчивого отслеживания, прежде чем начинать новый набор. Аккуратно поворачивайте и наклоняйте умные очки; пауза перед каждым захватом. + Сделайте не менее 24 различных видов неподвижной калибровочной цели. + Поворачивайте умные очки влево и вправо, а также наклоняйте их вверх и вниз; движение без вращения не может откалибровать выравнивание камеры. + Неправдоподобная базовая линия камеры. + Поворачивайте голову в разных направлениях. + Недопустимое вращение камеры к голове. + Неправильное выравнивание камеры по отношению к голове. + Не удалось завершить калибровку. %1$s Ваши захваченные виды сохраняются. + Задержка перепроецирования %1$.2f пикселей превышает 2 пикселя. Перекалибровать. + %1$d / В обеих камерах обнаружено 24 угла шахматной доски. Держите полную калибровочную цель видимой и держитесь неподвижно. Если оно уже видно, выберите 12 дюймов или 30 см и измерьте это более близкое расстояние, прежде чем повторить попытку. + Цель калибровки видна, но ее глубину невозможно измерить достоверно. Держите смарт-очки неподвижно и держите калибровочную мишень плоской и хорошо освещенной, а затем повторите попытку. + Неверные измерения камеры. Держитесь спокойно и попробуйте еще раз. + Дистанционная проверка пройдена. + Еще раз проверьте расстояние от левой камеры до центра калибровочной цели, затем повторите попытку. + Камеры измерения %1$s; выбранное расстояние %2$s. %3$s + Перед началом калибровки дождитесь предварительного просмотра обеих камер. + Сохраненные представления можно пересчитать. Запустите новую калибровку для захвата текущей системы координат отслеживания. + Несоответствие контрольной суммы модели руки. + OpenCV не удалось загрузить. + Виртуальный экран 6DoF + Распознавание рук на GPU + По умолчанию используется CPU. Режим GPU экспериментальный и может вызывать перезапуск SteamVR. Выбор сбрасывается при перезапуске отслеживания. + Распознавание рук недоступно: %1$s. Измените режим CPU/GPU или выключите и снова включите управление руками, чтобы повторить попытку. diff --git a/app/src/main/res/values-sv/strings.xml b/app/src/main/res/values-sv/strings.xml index 45eb0e035c..4ddc7eacca 100644 --- a/app/src/main/res/values-sv/strings.xml +++ b/app/src/main/res/values-sv/strings.xml @@ -2366,14 +2366,14 @@ Skärm Uppdateringsfrekvens 3D (sida vid sida) - Varje öga får sin egen halva av en bild på 3840×1080. Om bilden försvinner håller du in glasögonens 2D/3D-knapp. + Växla de smarta glasögonen till sida-vid-sida 3D. Huvudspårning styrs separat. 3D-signalen kunde inte bekräftas. Försök igen när 2D-bilden är tillbaka. Ingen bild: glasögonen är i ett läge som den här telefonen inte kan skicka. Håll in deras 2D/3D-knapp, eller koppla ur dem och anslut dem igen. 3D-uppdateringsfrekvens 3D för VR-spel Växlar till 3D medan SteamVR körs och tillbaka efteråt. - 3D-bild - Automatiskt: SteamVR fyller synfältet; andra spel svävar som en skärm i 3D och förblir platta i 2D. + Bild + Automatiskt visar platt innehåll i båda ögonen och detekterar SteamVR. Välj Sida-vid-sida-spel för SBS-innehåll. Automatiskt Virtuell skärm Sida vid sida-spel @@ -2383,20 +2383,20 @@ De här inställningarna gäller när Spel i glasögonen är på och spelet visas där. Automatiskt visar det här 2D-spelet i helskärm. Använd en virtuell skärm för att justera bredd, avstånd och huvudspårning. Använd virtuell skärm - SteamVR fyller hela vyn. Justera synfältet nedan; bredd och avstånd gäller bara en virtuell skärm. + SteamVR fyller vyn. Justera dess synfält i VR; bredd och avstånd gäller endast för en virtuell skärm. Sida vid sida-spel fyller varje ögas bild. Bredd och avstånd gäller bara en virtuell skärm. Automatiskt håller det här 2D-spelet fast i synfältet. Välj Virtuell skärm under Skärm för att använda huvudspårning. Huvudspårning gäller en virtuell skärm eller ett SteamVR-spel som körs. - Glasögon + Enhet Ljusstyrka Volym Solskydd Gör de främre glasen mörkare. - Huvudspårning + Spårning Huvudspårning Glasögonens egna sensorer vrider den virtuella skärmen och SteamVR med ditt huvud. Centrera vyn - Centrera + Centrera skärmen igen SteamVR-synfält Lägre för SteamVR närmare och fyller glasögonen; högre visar mer runt dig. Spelar på %1$s @@ -2417,8 +2417,8 @@ Ta bort den sparade kalibreringen och återställ modellens standardvärden? Centrera vyn när du har tagit på dig glasögonen igen. Återställ Handspårning - Spåra dina händer med kameran? - Kameran kan se dina händer. Utan ansluten handkontroll blir dina bara händer VR-händerna: nyp ihop tummen och pekfingret för att klicka, knyt handen för att greppa, och vänd handflatan mot dig och nyp för att öppna menyn. Med Joy-Con placerar den dem där dina händer faktiskt är. Bilderna behandlas på den här enheten och sparas eller skickas aldrig. + Spåra händer eller Joy-Con-kontroller med telefonkameran? + Utan någon kontroll ansluten spårar telefonkameran dina bara händer i VR: nyp ihop tummen och pekfingret för att klicka, stäng handen för att gripa tag och vänd handflatan mot dig och nyp ihop för att öppna menyn. Med parade Joy-Con-kontroller spårar kameran deras position medan Joy-Con-kontrollerna ger rotation och knappinmatning. Bilder bearbetas på den här enheten och sparas eller skickas aldrig. Bakre kameran Rekommenderas. Oftast skarpare och bredare. Främre kameran @@ -2426,7 +2426,7 @@ Använd kameran Inte nu Handspårning med kamera - Utan ansluten handkontroll blir dina händer VR-händerna: nyp för att klicka, handflatan mot dig och nyp för menyn. Med Joy-Con placeras de där kameran ser dem. Bilderna stannar på den här enheten. + Använd telefonkameran för gester med bara händer eller för att placera parade Joy-Con-kontroller i VR. Joy-Con-kontrollerna ger rotation och knappinmatningar. Pausar medan de smarta glasögonen spårar dina händer eller Joy-Con-kontroller. Bilder bearbetas endast på den här enheten. Kamera Kameraåtkomst Tillåt kameraåtkomst så att handspårningen kan starta. @@ -2680,4 +2680,208 @@ Konverterar %1$s för Steam. Håll DroidDeck öppet. Enheten kan inte avkoda videon. Kunde inte importera videon + Luma Ultra-kameror — Experimentell + Joy-Con-positionsspårning + Använd smartglasögonens kameror för att placera dina parade Joy-Con-kontroller. Rotation och knappinmatningar kommer från Joy-Con-kontrollerna. Positionen uppskattas när dina handleder är dolda. Ersätter kontroller som manövreras med bara händer och pausar telefonkameran. Rikta Joy-Con-kontrollerna framåt när du ansluter eller återställer spårningscentret. + Aktivera positionsspårning först. Kräver rörelsekompatibla Joy-Con-kontroller på Android 12 eller senare. Av som standard. + Smarta glasögon + Skärm- och huvudspårningsinställningar delas mellan DroidDeck-menyer, spel och skrivbordssessioner. + Anslut smartglasögon för att ändra deras skärm- och spårningsinställningar. Dina sparade inställningar sparas när du kopplar från. + VR + Visningsläge + 2D-utgång + 3D-utgång + Bild och virtuell skärm + Position och golvnivå + Spårning av händer — Experimentell + Spårningsstatus + 2D-upplösning + 3D-upplösning + VR-upplösning + Automatisk + Samma som 2D/3D + Utgångsupplösning per öga. + Aktivera Spel på smarta glasögon för att välja skärmens ursprungliga 30 Hz-läge. + 3DoF virtuell skärm + Förankra platta spel framför dig så att du kan titta dig omkring. Aktiverar Spel på smarta glasögon utan att växla till 3D. + Bredd och avstånd uppdaterar den spårade virtuella skärmen för DroidDeck-menyer, spel och skrivbordssessioner omedelbart. + Positionsspårning inkluderar huvudrotation i SteamVR. För spårning endast med rotation, stäng av positionsspårning. + Styr huvudrörelser på den virtuella skärmen. Positionsspårning inkluderar huvudrotation i SteamVR. + Snabbåtgärder + Titta dit du vill ha skärmen och återställ sedan spårningscentret för att ställa in dess höjd och riktning. + Centrera Joy-Con igen + Telefonkamera — Experimentell + Spåra händer eller Joy-Con-kontroller + Positionsspårning — experimentell + Fysisk rörelse i VR och runt virtuella skärmar. Det tar en stund att starta om spårningen. + Aktuell ögonhöjd över golvet + Ställ in golvnivå från aktuell höjd + Ställ in golvnivå + Stereokamerainställningar och diagnostik + Kontrollera kamerakalibreringen och spårningen av händerna innan du spelar. + Öppna inställningar + Kontroller som används med bara händer + Använd de smarta glasögons kameror för att sikta med händerna, nyp för att klicka och stäng handen för att gripa i VR. Gamepad-spakarna rör sig och vrider sig. Ersätter Joy-Con positionsspårning. Kan lagga eller förlora spårning under spel. + Aktivera kontroller som används med bara händer under Luma Ultra-kameror i Spårning. Visa öppna händer först. + Delad Luma Ultra-kalibrering + Använd den delade Luma Ultra-basen. Kalibrera dina egna smarta glasögon för att verifiera deras noggrannhet. + Uppmätt kalibrering verifierad + Validering krävs + Kontroller som används med bara händer blir tillgängliga efter att den uppmätta avståndskontrollen har godkänts. + Spårning förlorad + Titta långsamt omkring i ett väl upplyst rum.\nHåll spårningskamerorna borta och vänd dig mot möbler eller andra synliga detaljer. + Fortfarande fast? På din telefon: smarta glasögon → Spårning → Öppna inställning → Visa diagnostik → Starta om spårning. + Smarta glasögon bortkopplade + Kontrollera USB-anslutningen och anslut de smarta glasögonen igen.\nAcceptera USB-åtkomstprompten på din telefon om den visas. + När du är ansluten, titta långsamt runt i ett väl upplyst rum för att återställa spårningen. + Omcentrering behövs + Spårningen har återvänt till en ny position.\nTitta framåt och tryck sedan på återställ spårningscenter på din telefon. + Du kan även hitta återställning av spårningscenter i smarta glasögon → Spårning → Öppna inställningar. Din sparade kamerakalibrering sparas. + Håll still ett ögonblick + Återställning av spårningscenter pågår.\nHåll de smarta glasögonen stilla medan spårningen stabiliseras. + Den här skärmen stängs automatiskt när huvudspårning är klar. + Stabiliserad siktning med händerna + Sikta från din axel genom din handflata. Stäng av för handledskontrollerad rotation. + Rumsliga inställningar + Väntar på spårning... + Vänster och höger spårningskameror + Kamerasynkronisering + Klar + Väntar på att kamera och huvudspårning ska ställa upp. Håll de smarta glasögonen anslutna. + 1. Förbered kalibreringsmålet + Skriv ut i verklig storlek + Varje kvadrat måste mäta 30 mm (1,181 tum). Montera arket plant på en styv yta i ett väl upplyst område. + Skriv ut kalibreringsmönster + 2. Fånga olika vyer + Håll kalibreringsmålet stillastående + Flytta de smarta glasögonen närmare, längre och i sidled. Vrid dem åt vänster/höger, vinkla dem upp/ned och luta dem i sidled. Behåll kalibreringsmålet i båda kamerorna och pausa en kort stund före varje tagning. + Starta ny kalibrering + Väntar på kamerasynkronisering. + Starta en ny kalibrering för att samla in vyer. + Håll kalibreringsmålet synligt i båda förhandsvisningarna. Fånga minst 24 skarpa vyer från olika vinklar. + Fångar... + Fånga kalibreringsmålvy + Beräkna kamerainriktning + Beräknar... + Beräkna kalibrering + 3. Kontrollera avståndet + Uppmätt avstånd + Börja med 12 tum eller 30 cm så att de tryckta markörerna är lättare att upptäcka. Välj det exakta mått du ska använda. + Vänster kamera till mitten av kalibreringsmålet + Kontrollerar avstånd... + Validera avstånd + Diagnostik + Visa diagnostik + Verktyg för återställning av kameratiming och spårning. + Kameratiming + Indata från spårning av händer + Väntar på kameratiming. + Kamerabilder + GPU-detektering av händer + CPU är standard. GPU är experimentell och kan få SteamVR att starta om. Detta val återställs när spårningen startar om. + Lite detektering av händermodeller + Använd Lite handflatsdetektor och Lite nyckelpunkter på händerna. Kontrollera siktnings-, nyp- och greppprecisionen. Återställs när spårningen startar om. + Automatisk ingångsfrekvens för spårning av händer + Justera ingången till bearbetningshastighet. Återställs när spårningen startar om. + Begränsa ingångsfrekvensen för spårning av händer + Använd hälften av kamerabilderna. Stäng av för att jämföra den maximala frekvensen. Återställs när spårningen startar om. + Diagnostisk infångning + Spara ett stereobildpar lokalt. Bilder sparas endast på begäran. + Spara kamerabild + Starta om spårning + Används om spårningen inte återhämtar sig i ett väl upplyst område. En omstart kräver ett nytt spårningsursprung. + Starta om + Starta om spårning? + Osparade kalibreringsvyer kommer att gå förlorade. Håll de smarta glasögonen stilla efteråt och återställ spårningscentret när spårningen återställs. + %1$d / 24 visningar tagna + Inspelning pausad: %1$s + Mät %1$s. Visa hela kalibreringsmålet i båda förhandsvisningarna och håll sedan stilla. + %1$.1f Hz • bildålder %2$.1f ms • bearbetning %3$.1f ms + Ingångsgräns %1$.1f Hz • %2$.0f%% för kamerabilder. Huvudspårning fortsätter med sin maximala frekvens. + %1$d bearbetade • %2$d tappade • %3$d hoppade över inmatningsgräns + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra-kalibrering + Skriv ut vid 100%/verklig storlek. Varje kvadrat: 30 mm (1,181 tum). + Håll kalibreringsmålet plant och stationärt; flytta de smarta glasögonen mellan bilderna. + Skalkontroll: 100 mm (3,937 tum) mellan fästingar + 12 tum (30,48 cm) + 30 cm (11,81 tum) + 20 tum (50,8 cm) + 50 cm (19,69 tum) + Inaktiverad + Väntar på stabil spårning + Frånkopplad + Styrenheter som manövreras med bara händer är avstängda + Positionsspårning är avstängd eller smarta glasögon är bortkopplade + Återställning av spårningscenter begärs — håll still medan spårningen stabiliseras + Spårning förlorad – möta ett väl upplyst område med synliga detaljer + Spårningsursprung ändras — tryck på återställ spårningscenter och håll sedan still + 6DoF aktiv + Anslut Luma Ultra och aktivera positionsspårning. + Kalibrering verifierad för denna anslutning. + Kalibrering verifierad och sparad. + Väntar på stereokameror + Väntar på spårning av händer + Håll 5 × 7 kalibreringsmålet stillastående. Fånga 24+ vyer medan du flyttar och roterar de smarta glasögonen. + Väntar på nästa kamerabild. Håll de smarta glasögonen stilla. + Kontrollerar nästa kamerabild. Håll hela kalibreringsmålet synligt och håll stilla. + Starta kalibreringen först + Ingen ny kamerabild kom. Kontrollera anslutningen för smarta glasögon och kameraförhandsvisningar och försök sedan igen. + Kameraklockan återställd + Spårningskoordinatsystemet har ändrats. Dina vyer sparas för omberäkning. Återställ spårningscenter och starta sedan en ny uppsättning för att fånga fler vyer. + enhetskalibrering laddad + Luma Ultra-baskalibrering laddad + kalibrering krävs + Tryck på Starta ny kalibrering först. + Återställning av spårningscenter väntar på stabil spårning. Håll still en stund. + Spårning ändras. Tryck på återställ spårningscenter en gång och håll sedan still innan du fångar. + Bilden avvisades: huvudspårningen var inte synkroniserad eller ändrades under bildtagningen. Håll stilla och försök igen. + Beräkna kamerainriktningen innan du kontrollerar avståndet. + kamerabehandling misslyckades + Huvudspårningen ändrades under detektering av händer + Väntar på kamera- och huvudsynkronisering + Inga handleder upptäcktes. Håll dina Joy-Con-handtag framför de smarta glasögonen + Inga händer upptäckts. Visa öppna handflattor framför de smarta glasögonen + Handleder synliga i endast en kamera; håll dina kontroller i den delade vyn + Händer synliga i endast en kamera; håll båda handflatorna i den delade vyn + Båda kamerorna ser händer, men vänster/höger-matchning är tvetydig + Händer upptäcktes, men stereodjupet är inkonsekvent + Handledsposition avvisad av stereo- eller rörelsekontroller + Stereopunkter upptäcktes, men palmgeometrin är inkonsekvent + Komplett kalibrering och avståndskontrollen för att aktivera händer + Väntar på stabil huvudspårning; återställ spårningscenter om det begärs. + Kameraobservation är för gammal; väntar på ett nytt par + Fit %1$.2f px. Mät det valda avståndet från den vänstra kameran till kalibreringsmålets centrum och validera sedan. + OpenCV inte tillgängligt: %1$s + %1$d sparade vyer återställda. Beräkna kalibreringen för att försöka igen, eller starta en ny uppsättning för att fånga mer. + Fångad %1$d / 24 visningar. Håll kalibreringsmålet fixerat; flytta de smarta glasögonen för nästa vy. + Bilden avvisades: %1$d / 12 nödvändiga hörn synliga i båda kamerorna. Visa mer av kalibreringsmålet, håll stilla och försök sedan igen. + Avståndskontrollen kunde inte avslutas: %1$s. Försök igen. + Detektering av händer otillgänglig: %1$s. Byt CPU/GPU eller växla kontroller som manövreras med bara händer för att försöka igen. + Detektering av händer överskred %1$d ms; observation förkastad + %1$d / 2 Joy-Con handledspositioner uppmätt med stereo + Spårade handflator: %1$d / 2; nypgest redo: %2$d; greppgest redo: %3$d + Sparad diagnostik till %1$s + Spårning av händer stoppade: %1$s + Stereo %1$d×%2$d; %3$s + Huvudspårning och kalibreringsmålet inte överensstämmer med %1$s (gräns 5 cm / 2 in). Håll kalibreringsmålet fixerat och vänta på stadig spårning innan du startar en ny uppsättning. Vrid och luta de smarta glasögonen försiktigt; pausa före varje tagning. + Fånga minst 24 olika vyer av det stationära kalibreringsmålet. + Vrid de smarta glasögonen åt vänster och höger och luta dem upp och ner; rörelse utan rotation kan inte kalibrera kamerainriktningen. + Otrolig kamerabaslinje + Flytta huvudet genom mer varierande orienteringar. + Ogiltig kamera-till-huvud-rotation + Kamera-till-huvud-inriktningen är inkonsekvent. + Kalibreringen kunde inte avslutas. %1$s Dina tagna vyer sparas. + Uthållet omprojektionsfel %1$.2f px överstiger 2 px. Omkalibrera. + %1$d / 24 rutiga hörn upptäckts i båda kamerorna. Håll hela kalibreringsmålet synligt och håll stilla. Om det redan är synligt, välj 12 tum eller 30 cm och mät det närmare avståndet innan du försöker igen. + Kalibreringsmålet är synligt, men dess djup kunde inte mätas tillförlitligt. Håll de smarta glasögonen stilla och håll kalibreringsmålet plant och väl upplyst, försök sedan igen. + Kameramåttet var ogiltigt. Håll still och försök igen. + Avståndskontroll godkänd. + Kontrollera avståndet från vänster kamera till kalibreringsmålets mitt och försök sedan igen. + Kameror uppmätt %1$s; valt avstånd %2$s. %3$s + Vänta på båda kameraförhandsvisningarna innan du börjar kalibrera. + Sparade vyer kan räknas om. Starta en ny kalibrering för att fånga i det aktuella spårningskoordinatsystemet. + Kontrollsumman för handmodellen inte överensstämmer + OpenCV kunde inte laddas + Virtuell skärm med 6DoF diff --git a/app/src/main/res/values-th/strings.xml b/app/src/main/res/values-th/strings.xml index 9f4e60ea05..c9cac80c45 100644 --- a/app/src/main/res/values-th/strings.xml +++ b/app/src/main/res/values-th/strings.xml @@ -2341,14 +2341,14 @@ หน้าจอ อัตรารีเฟรช 3D (แบบเคียงข้าง) - ตาแต่ละข้างจะเห็นภาพคนละครึ่งของภาพขนาด 3840×1080 หากภาพหายไป ให้กดปุ่ม 2D/3D ของแว่นตาค้างไว้ + เปลี่ยนแว่นตาอัจฉริยะเป็น 3 มิติแบบ side-by-side การติดตามศีรษะจะถูกควบคุมแยกต่างหาก ยังยืนยันสัญญาณ 3D ไม่ได้ ลองอีกครั้งเมื่อภาพ 2D กลับมา ไม่มีภาพ: แว่นตาอยู่ในโหมดที่โทรศัพท์นี้ส่งสัญญาณให้ไม่ได้ กดปุ่ม 2D/3D ของแว่นตาค้างไว้ หรือถอดสายแล้วเสียบใหม่ อัตรารีเฟรช 3D 3D สำหรับเกม VR เปลี่ยนเป็น 3D ขณะที่ SteamVR ทำงาน และเปลี่ยนกลับเมื่อเลิกใช้ - ภาพ 3D - อัตโนมัติ: SteamVR แสดงเต็มมุมมอง ส่วนเกมอื่นจะลอยเป็นหน้าจอในโหมด 3D และแสดงภาพแบนในโหมด 2D + รูปภาพ + แสดงเนื้อหาแบบแบนราบโดยอัตโนมัติในทั้งสองตาและตรวจจับ SteamVR เลือกเกมแบบ Side-by-side สำหรับเนื้อหา SBS อัตโนมัติ หน้าจอเสมือน เกมแบบเคียงข้าง @@ -2358,20 +2358,20 @@ การตั้งค่าเหล่านี้จะมีผลเมื่อเปิด “แสดงเกมบนแว่นตา” และเกมกำลังแสดงอยู่บนแว่นตา โหมดอัตโนมัติจะแสดงเกม 2D นี้แบบเต็มจอ ใช้หน้าจอเสมือนเพื่อปรับความกว้าง ระยะห่าง และการติดตามศีรษะ ใช้หน้าจอเสมือน - SteamVR แสดงเต็มมุมมอง ปรับขอบเขตการมองเห็นได้ด้านล่าง ส่วนความกว้างและระยะห่างใช้กับหน้าจอเสมือนเท่านั้น + SteamVR เต็มมุมมอง ปรับมุมมองใน VR ความกว้างและระยะทางจะใช้กับหน้าจอเสมือนเท่านั้น เกมแบบเคียงข้างจะแสดงเต็มภาพในตาแต่ละข้าง ความกว้างและระยะห่างใช้กับหน้าจอเสมือนเท่านั้น โหมดอัตโนมัติจะตรึงเกม 2D นี้ไว้ในมุมมอง เลือก “หน้าจอเสมือน” ในส่วน “หน้าจอ” เพื่อใช้การติดตามศีรษะ การติดตามศีรษะใช้กับหน้าจอเสมือนหรือเกม SteamVR ที่กำลังทำงาน - แว่นตา + อุปกรณ์ ความสว่าง ระดับเสียง กันแดด ทำให้เลนส์ด้านหน้ามืดลง - การติดตามศีรษะ + การติดตาม การติดตามศีรษะ เซ็นเซอร์ในตัวแว่นตาจะหมุนหน้าจอเสมือนและ SteamVR ตามศีรษะของคุณ จัดมุมมองให้อยู่ตรงกลาง - จัดกึ่งกลาง + ตั้งศูนย์หน้าจอใหม่ ขอบเขตการมองเห็นของ SteamVR ค่าต่ำจะดึง SteamVR เข้ามาใกล้และเต็มแว่นตา ค่าสูงจะแสดงสิ่งรอบตัวคุณได้มากขึ้น กำลังเล่นบน %1$s @@ -2392,8 +2392,8 @@ ลบการปรับเทียบที่บันทึกไว้และคืนค่าเริ่มต้นของรุ่น? สวมแว่นตาอีกครั้งแล้วจัดกึ่งกลางใหม่ รีเซ็ต การติดตามมือ - ติดตามมือของคุณด้วยกล้อง? - กล้องมองเห็นมือของคุณได้ เมื่อไม่ได้เชื่อมต่อคอนโทรลเลอร์ มือเปล่าของคุณจะกลายเป็นมือใน VR: แตะนิ้วโป้งกับนิ้วชี้เข้าหากันเพื่อคลิก กำมือเพื่อจับ และหันฝ่ามือเข้าหาตัวแล้วแตะนิ้วเข้าหากันเพื่อเปิดเมนู เมื่อใช้ Joy-Con กล้องจะวางไว้ตรงตำแหน่งที่มือของคุณอยู่จริง ภาพจะถูกประมวลผลบนอุปกรณ์นี้เท่านั้น และจะไม่ถูกบันทึกหรือส่งออกไปที่ใด + ติดตามมือหรือคอนโทรลเลอร์ Joy-Con ด้วยกล้องโทรศัพท์? + หากไม่มีคอนโทรลเลอร์เชื่อมต่อ กล้องโทรศัพท์จะติดตามมือเปล่าของคุณใน VR: บีบนิ้วโป้งและนิ้วชี้เพื่อคลิก ปิดมือเพื่อจับ และหันฝ่ามือเข้าหาตัวแล้วบีบเพื่อเปิดเมนู หากเชื่อมต่อคอนโทรลเลอร์ Joy-Con กล้องจะติดตามตำแหน่งของคอนโทรลเลอร์ ในขณะที่คอนโทรลเลอร์ Joy-Con จะให้การหมุนและการกดปุ่ม รูปภาพจะถูกประมวลผลบนอุปกรณ์นี้และจะไม่ถูกบันทึกหรือส่ง กล้องหลัง แนะนำ โดยทั่วไปจะคมชัดและมีมุมมองกว้างกว่า กล้องหน้า @@ -2401,7 +2401,7 @@ ใช้กล้อง ไม่ใช่ตอนนี้ การติดตามมือด้วยกล้อง - เมื่อไม่ได้เชื่อมต่อคอนโทรลเลอร์ มือของคุณจะกลายเป็นมือใน VR: แตะนิ้วเข้าหากันเพื่อคลิก หันฝ่ามือเข้าหาตัวแล้วแตะนิ้วเพื่อเปิดเมนู เมื่อใช้ Joy-Con จะจัดวางตามตำแหน่งที่กล้องมองเห็น ภาพจะอยู่ในอุปกรณ์นี้เท่านั้น + ใช้กล้องโทรศัพท์สำหรับการใช้ท่าทางมือเปล่าหรือเพื่อกำหนดตำแหน่งคอนโทรลเลอร์ Joy-Con ที่จับคู่ไว้ใน VR คอนโทรลเลอร์ Joy-Con จะให้การหมุนและการกดปุ่ม หยุดชั่วคราวในขณะที่แว่นตาอัจฉริยะติดตามมือหรือคอนโทรลเลอร์ Joy-Con ของคุณ รูปภาพจะถูกประมวลผลบนอุปกรณ์นี้เท่านั้น กล้อง สิทธิ์กล้อง อนุญาตสิทธิ์กล้องเพื่อให้เริ่มการติดตามมือได้ @@ -2655,4 +2655,208 @@ กำลังแปลง %1$s สำหรับ Steam โปรดเปิด DroidDeck ค้างไว้ อุปกรณ์นี้ถอดรหัสวิดีโอนั้นไม่ได้ นำเข้าวิดีโอนี้ไม่ได้ + กล้อง Luma Ultra — ทดลอง + การติดตามตำแหน่ง Joy-Con + ใช้กล้องของแว่นตาอัจฉริยะเพื่อกำหนดตำแหน่งคอนโทรลเลอร์ Joy-Con ที่จับคู่ไว้ การหมุนและการกดปุ่มจะมาจากคอนโทรลเลอร์ Joy-Con ตำแหน่งจะถูกประมาณเมื่อข้อมือของคุณถูกซ่อนอยู่ แทนที่คอนโทรลเลอร์ที่ใช้งานด้วยมือเปล่าและหยุดการติดตามของกล้องโทรศัพท์ชั่วคราว ชี้คอนโทรลเลอร์ Joy-Con ไปข้างหน้าเมื่อเชื่อมต่อหรือรีเซ็ตศูนย์กลางการติดตาม + เปิดใช้งานการติดตามตำแหน่งก่อน ต้องใช้คอนโทรลเลอร์ Joy-Con ที่รองรับการเคลื่อนไหวบน Android 12 หรือใหม่กว่า ปิดใช้งานโดยค่าเริ่มต้น + แว่นตาอัจฉริยะ + การตั้งค่าการแสดงผลและการติดตามศีรษะจะใช้ร่วมกันในเมนู DroidDeck เกม และเซสชันเดสก์ท็อป + เชื่อมต่อแว่นตาอัจฉริยะเพื่อเปลี่ยนการตั้งค่าการแสดงผลและการติดตาม การตั้งค่าที่บันทึกไว้ของคุณจะยังคงอยู่เมื่อคุณตัดการเชื่อมต่อ + VR + โหมดการแสดงผล + เอาต์พุต 2 มิติ + เอาต์พุต 3 มิติ + รูปภาพและหน้าจอเสมือน + ตำแหน่งและระดับพื้น + การติดตามมือ — ทดลอง + สถานะการติดตาม + ความละเอียด 2 มิติ + ความละเอียด 3 มิติ + ความละเอียด VR + อัตโนมัติ + เหมือนกับ 2 มิติ / 3 มิติ + ความละเอียดเอาต์พุตต่อตา + เปิดใช้งาน Game on smart glasses เพื่อเลือกโหมด 30 Hz ดั้งเดิมของจอแสดงผล + หน้าจอเสมือน 3DoF + ตรึงเกมแบบแบนไว้ข้างหน้าคุณเพื่อให้คุณสามารถมองไปรอบๆ ได้ เปิดใช้งาน Game on smart glasses โดยไม่ต้องเปลี่ยนเป็น 3 มิติ + ความกว้างและระยะทางจะอัปเดตหน้าจอเสมือนที่ติดตามสำหรับเมนู เกม และเซสชันเดสก์ท็อปของ DroidDeck ทันที + การติดตามตำแหน่งรวมถึงการหมุนศีรษะใน SteamVR สำหรับการติดตามการหมุนอย่างเดียว ให้ปิดการติดตามตำแหน่ง + ควบคุมการเคลื่อนไหวของศีรษะบนหน้าจอเสมือน การติดตามตำแหน่งรวมถึงการหมุนศีรษะใน SteamVR + การดำเนินการด่วน + มองไปยังตำแหน่งที่คุณต้องการให้หน้าจออยู่ จากนั้นรีเซ็ตศูนย์กลางการติดตามเพื่อตั้งค่าความสูงและทิศทาง + ตั้งศูนย์ Joy-Con ใหม่ + กล้องโทรศัพท์ — ทดลอง + ติดตามมือหรือคอนโทรลเลอร์ Joy-Con + หน้าจอเสมือน 6DoF + การติดตามตำแหน่ง — ทดลอง + การเคลื่อนไหวทางกายภาพใน VR และรอบๆ หน้าจอเสมือน การเริ่มต้นการติดตามใหม่ใช้เวลาสักครู่ + ความสูงของดวงตาปัจจุบันเหนือพื้น + ตั้งระดับพื้นจากความสูงปัจจุบัน + ตั้งระดับพื้น + การตั้งค่าและการวินิจฉัยกล้องสเตอริโอ + ตรวจสอบการปรับเทียบกล้องและการติดตามมือก่อนเล่น + เปิดการตั้งค่า + คอนโทรลเลอร์ที่ใช้งานด้วยมือเปล่า + ใช้กล้องแว่นตาอัจฉริยะเพื่อเล็งด้วยมือของคุณ บีบเพื่อคลิก และกำมือเพื่อจับใน VR จอยสติ๊กของเกมแพดจะเคลื่อนที่และหมุน แทนที่การติดตามตำแหน่งของ Joy-Con อาจเกิดอาการหน่วงหรือสูญเสียการติดตามระหว่างเล่นเกม + เปิดใช้งานคอนโทรลเลอร์ที่ใช้งานด้วยมือเปล่าภายใต้กล้อง Luma Ultra ในการติดตาม แสดงมือที่เปิดอยู่ก่อน + การปรับเทียบ Luma Ultra ที่ใช้ร่วมกัน + การใช้ฐาน Luma Ultra ที่ใช้ร่วมกัน ปรับเทียบแว่นตาอัจฉริยะของคุณเองเพื่อตรวจสอบความถูกต้อง + การวัดค่าการปรับเทียบได้รับการตรวจสอบแล้ว + ต้องมีการตรวจสอบความถูกต้อง + ตัวควบคุมที่ใช้งานด้วยมือเปล่าจะพร้อมใช้งานหลังจากผ่านการตรวจสอบระยะทางที่วัดได้ + การติดตามหายไป + มองไปรอบๆ อย่างช้าๆ ในห้องที่มีแสงสว่างเพียงพอ\nรักษาให้กล้องติดตามอยู่ในตำแหน่งที่ชัดเจนและหันหน้าไปทางเฟอร์นิเจอร์หรือรายละเอียดอื่นๆ ที่มองเห็นได้ + ยังติดอยู่เหรอ? บนโทรศัพท์ของคุณ: แว่นตาอัจฉริยะ → การติดตาม → เปิดการตั้งค่า → แสดงการวินิจฉัย → เริ่มการติดตามอีกครั้ง + แว่นตาอัจฉริยะถูกตัดการเชื่อมต่อ + ตรวจสอบการเชื่อมต่อ USB และเชื่อมต่อแว่นตาอัจฉริยะอีกครั้ง\nยอมรับข้อความแจ้งการเข้าถึง USB บนโทรศัพท์ของคุณหากปรากฏขึ้น + เมื่อเชื่อมต่อแล้ว ให้มองไปรอบๆ อย่างช้าๆ ในห้องที่มีแสงสว่างเพียงพอเพื่อคืนค่าการติดตาม + จำเป็นต้องตั้งศูนย์ใหม่ + การติดตามกลับมาอยู่ในตำแหน่งใหม่แล้ว\nมองไปข้างหน้า จากนั้นแตะรีเซ็ตศูนย์กลางการติดตามบนโทรศัพท์ของคุณ + คุณสามารถค้นหาตัวเลือกการรีเซ็ตจุดศูนย์กลางการติดตามได้ในแว่นตาอัจฉริยะ → การติดตาม → เปิดการตั้งค่า การปรับเทียบกล้องที่คุณบันทึกไว้จะยังคงอยู่ + จงนิ่งไว้ครู่หนึ่ง + กำลังดำเนินการรีเซ็ตจุดศูนย์กลางการติดตาม\nโปรดรักษาแว่นตาอัจฉริยะให้นิ่งในขณะที่การติดตามกำลังเสถียร + หน้าจอนี้จะปิดโดยอัตโนมัติเมื่อพร้อมการติดตามศีรษะ + การเล็งด้วยมืออย่างมั่นคง + เล็งจากไหล่ผ่านฝ่ามือ ปิดเพื่อควบคุมการหมุนด้วยข้อมือ + การตั้งค่าเชิงพื้นที่ + กำลังรอการติดตาม... + กล้องติดตามด้านซ้ายและขวา + การซิงโครไนซ์กล้อง + พร้อมแล้ว + กำลังรอให้กล้องและการติดตามศีรษะเข้าแถว เชื่อมต่อแว่นตาอัจฉริยะไว้ + 1. เตรียมเป้าหมายการสอบเทียบ + พิมพ์ตามขนาดจริง + แต่ละสี่เหลี่ยมจัตุรัสต้องวัดได้ 30 มม. (1.181 นิ้ว) ติดแผ่นเรียบบนพื้นผิวแข็งในบริเวณที่มีแสงสว่างเพียงพอ + พิมพ์แผ่นปรับเทียบ + 2. เก็บภาพมุมมองที่แตกต่าง + ทำให้เป้าหมายการสอบเทียบอยู่กับที่ + เลื่อนแว่นตาอัจฉริยะเข้ามาใกล้ ไกลขึ้น และไปด้านข้าง หมุนไปทางซ้าย/ขวา เอียงขึ้น/ลง และเอียงไปด้านข้าง เก็บเป้าหมายการปรับเทียบไว้ในกล้องทั้งสองตัวและหยุดชั่วคราวก่อนจับภาพแต่ละครั้ง + เริ่มการปรับเทียบใหม่ + กำลังรอการซิงโครไนซ์กล้อง + เริ่มการปรับเทียบใหม่เพื่อรวบรวมมุมมอง + ทำให้เป้าหมายการปรับเทียบมองเห็นได้ในหน้าตัวอย่างทั้งสอง ถ่ายภาพมุมที่คมชัดอย่างน้อย 24 ภาพจากมุมที่แตกต่างกัน + กำลังจับภาพ... + บันทึกมุมมองเป้าหมายการปรับเทียบ + คำนวณการจัดตำแหน่งกล้อง + กำลังคำนวณ... + คำนวณการปรับเทียบ + 3. ตรวจสอบระยะทาง + ระยะทางที่วัดได้ + เริ่มต้นด้วย 12 นิ้วหรือ 30 ซม. เพื่อให้ตรวจจับมาร์กเกอร์ที่พิมพ์ได้ง่ายขึ้น เลือกการวัดที่แน่นอนที่คุณจะใช้ + ระยะจากกล้องด้านซ้ายถึงจุดกึ่งกลางของเป้าสอบเทียบ + กำลังตรวจสอบระยะทาง... + ตรวจสอบระยะทาง + การวินิจฉัย + แสดงการวินิจฉัย + เครื่องมือกู้คืนเวลาและการติดตามของกล้อง + จังหวะเวลาของกล้อง + อินพุตจากการติดตามมือ + กำลังรอจังหวะการทำงานของกล้อง + ภาพจากกล้อง + การตรวจจับ GPU ของมือ + CPU เป็นค่าเริ่มต้น GPU อยู่ระหว่างการทดลอง และอาจทำให้ SteamVR รีสตาร์ทได้ ตัวเลือกนี้จะรีเซ็ตเมื่อเริ่มการติดตามอีกครั้ง + ตรวจจับมือด้วยโมเดล Lite + ใช้เครื่องตรวจจับฝ่ามือ Lite และจุดสำคัญ Lite บนมือ ตรวจสอบความแม่นยำในการเล็ง หยิก และคว้า รีเซ็ตเมื่อการติดตามเริ่มต้นใหม่ + ปรับอัตราอินพุตการติดตามมืออัตโนมัติ + ปรับอินพุตตามความเร็วในการประมวลผล รีเซ็ตเมื่อการติดตามเริ่มต้นใหม่ + จำกัดอัตราอินพุตการติดตามมือ + ใช้ภาพจากกล้องครึ่งหนึ่ง ปิดเพื่อเปรียบเทียบความถี่สูงสุด รีเซ็ตเมื่อการติดตามเริ่มต้นใหม่ + การจับเพื่อการวินิจฉัย + บันทึกคู่ภาพสเตอริโอหนึ่งคู่ในเครื่อง รูปภาพจะถูกบันทึกเมื่อมีการร้องขอเท่านั้น + บันทึกภาพจากกล้อง + เริ่มการติดตามอีกครั้ง + ใช้หากการติดตามไม่ฟื้นตัวในพื้นที่ที่มีแสงสว่างเพียงพอ การรีสตาร์ทจำเป็นต้องมีจุดเริ่มต้นการติดตามใหม่ + เริ่มต้นใหม่ + เริ่มการติดตามใหม่หรือไม่? + มุมมองการปรับเทียบที่ไม่ได้บันทึกไว้จะหายไป โปรดรักษาแว่นตาอัจฉริยะให้นิ่งหลังจากนั้น และรีเซ็ตจุดศูนย์กลางการติดตามเมื่อการติดตามกลับมาใช้งานได้ + %1$d / มีการดู 24 ครั้ง + การจับภาพหยุดชั่วคราว: %1$s + วัด %1$s แสดงเป้าหมายการสอบเทียบที่สมบูรณ์ในหน้าตัวอย่างทั้งสอง จากนั้นให้นิ่งไว้ + %1$.1f Hz • อายุภาพ %2$.1f ms • การประมวลผล %3$.1f ms + ขีดจำกัดอินพุต %1$.1f Hz • %2$.0f%% ของภาพของกล้อง การติดตามศีรษะยังคงดำเนินต่อไปที่ความถี่สูงสุด + %1$d ประมวลผลแล้ว • %2$d ลดลง • %3$d ข้ามตามขีดจำกัดอินพุต + DroidDeck ChArUco 30 mm + DroidDeck - การสอบเทียบ Luma Ultra + พิมพ์ที่ 100% / ขนาดจริง แต่ละสี่เหลี่ยมจัตุรัส: 30 มม. (1.181 นิ้ว) + รักษาเป้าหมายการสอบเทียบให้เรียบและอยู่กับที่ ย้ายแว่นตาอัจฉริยะระหว่างการจับภาพ + การตรวจสอบสเกล: 100 มม. (3.937 นิ้ว) ระหว่างขีด + 12 นิ้ว (30.48 ซม.) + 30 ซม. (11.81 นิ้ว) + 20 นิ้ว (50.8 ซม.) + 50 ซม. (19.69 นิ้ว) + ปิดการใช้งาน + กำลังรอการติดตามที่เสถียร + ตัดการเชื่อมต่อ + ตัวควบคุมที่ทำงานด้วยมือเปล่าปิดอยู่ + การติดตามตำแหน่งปิดอยู่หรือแว่นตาอัจฉริยะถูกตัดการเชื่อมต่อ + ร้องขอการรีเซ็ตจุดศูนย์กลางการติดตาม — โปรดอยู่นิ่งในขณะที่การติดตามเสถียร + สูญเสียการติดตาม — หันหน้าไปทางบริเวณที่มีแสงสว่างเพียงพอพร้อมรายละเอียดที่มองเห็นได้ + จุดกำเนิดการติดตามเปลี่ยนไป — แตะรีเซ็ตจุดศูนย์กลางการติดตาม จากนั้นโปรดอยู่นิ่ง + 6DoF ใช้งานอยู่ + เชื่อมต่อ Luma Ultra และเปิดใช้งานการติดตามตำแหน่ง + การสอบเทียบได้รับการยืนยันสำหรับการเชื่อมต่อนี้ + ตรวจสอบและบันทึกการสอบเทียบแล้ว + กำลังรอกล้องสเตอริโอ + รอการติดตามมือ + ทำให้เป้าหมายการปรับเทียบ 5 × 7 อยู่กับที่ จับภาพได้มากกว่า 24 มุมมองขณะเคลื่อนย้ายและหมุนแว่นตาอัจฉริยะ + กำลังรอภาพจากกล้องถัดไป ถือแว่นตาอัจฉริยะให้นิ่ง + ตรวจสอบภาพจากกล้องถัดไป ให้มองเห็นเป้าหมายการสอบเทียบแบบเต็มและค้างไว้นิ่งๆ + เริ่มการปรับเทียบก่อน + ไม่มีภาพจากกล้องใหม่มาถึง ตรวจสอบการเชื่อมต่อแว่นตาอัจฉริยะและตัวอย่างกล้อง จากนั้นลองอีกครั้ง + รีเซ็ตนาฬิกาในกล้อง + ระบบพิกัดการติดตามเปลี่ยนไป มุมมองของคุณจะถูกบันทึกไว้สำหรับการคำนวณใหม่ รีเซ็ตจุดศูนย์กลางการติดตาม จากนั้นเริ่มต้นชุดใหม่เพื่อจับภาพมุมมองเพิ่มเติม + โหลดการปรับเทียบอุปกรณ์แล้ว + โหลดการปรับเทียบฐาน Luma Ultra แล้ว + ต้องมีการสอบเทียบ + แตะเริ่มการปรับเทียบใหม่ก่อน + การรีเซ็ตจุดศูนย์กลางการติดตามกำลังรอการติดตามที่เสถียร โปรดอยู่นิ่งสักครู่ + การติดตามเปลี่ยนไป แตะรีเซ็ตจุดศูนย์กลางการติดตามหนึ่งครั้ง จากนั้นโปรดอยู่นิ่งก่อนจับภาพ + การจับภาพถูกปฏิเสธ: การติดตามศีรษะไม่ซิงโครไนซ์ หรือมีการเปลี่ยนแปลงระหว่างการจับภาพ อยู่นิ่ง ๆ แล้วลองอีกครั้ง + คำนวณการจัดตำแหน่งกล้องก่อนตรวจสอบระยะห่าง + การประมวลผลกล้องล้มเหลว + การติดตามศีรษะเปลี่ยนไประหว่างการตรวจจับมือ + กำลังรอการซิงโครไนซ์กล้องและศีรษะ + ตรวจไม่พบข้อมือ วางที่จับคอนโทรลเลอร์ Joy-Con ไว้ด้านหน้าแว่นตาอัจฉริยะ + ตรวจไม่พบมือ แสดงฝ่ามือที่เปิดอยู่ด้านหน้าแว่นตาอัจฉริยะ + ข้อมือมองเห็นได้ในกล้องเพียงตัวเดียว ให้ที่จับคอนโทรลเลอร์ของคุณอยู่ในมุมมองที่ใช้ร่วมกัน + มือมองเห็นได้ในกล้องเพียงตัวเดียว เก็บฝ่ามือทั้งสองไว้ในมุมมองที่ใช้ร่วมกัน + กล้องทั้งสองมองเห็นมือ แต่การจับคู่ซ้าย/ขวาไม่ชัดเจน + ตรวจพบมือ แต่ความลึกของสเตอริโอไม่สอดคล้องกัน + ตำแหน่งข้อมือถูกปฏิเสธโดยการตรวจสอบสเตอริโอหรือการเคลื่อนไหว + ตรวจพบจุดสเตอริโอ แต่รูปทรงของฝ่ามือไม่สอดคล้องกัน + ทำการสอบเทียบและตรวจสอบระยะทางให้เสร็จสิ้นเพื่อเปิดใช้การติดตามมือ + กำลังรอการติดตามศีรษะที่เสถียร รีเซ็ตจุดศูนย์กลางการติดตามหากมีการร้องขอ + การสังเกตด้วยกล้องเก่าเกินไป รอคู่ใหม่ครับ + พอดี %1$.2f พิกเซล วัดระยะทางที่คุณเลือกจากกล้องด้านซ้ายไปยังศูนย์กลางเป้าหมายการสอบเทียบ จากนั้นตรวจสอบ + OpenCV ไม่พร้อมใช้งาน: %1$s + ถ่ายแล้ว %1$d / 24 ครั้ง รักษาเป้าหมายการสอบเทียบให้คงที่ เลื่อนแว่นตาอัจฉริยะเพื่อดูมุมมองถัดไป + การจับภาพถูกปฏิเสธ: %1$d / 12 มุมที่ต้องมองเห็นได้ในกล้องทั้งสองตัว แสดงเป้าหมายการสอบเทียบเพิ่มเติม ให้ค้างไว้แล้วลองอีกครั้ง + การตรวจสอบระยะทางไม่เสร็จสิ้น: %1$s ลองอีกครั้ง + การตรวจจับมือไม่พร้อมใช้งาน: %1$s เปลี่ยน CPU/GPU หรือตัวควบคุมสลับที่ทำงานด้วยมือเปล่าเพื่อลองอีกครั้ง + การตรวจจับมือเกิน %1$d ms; การสังเกตถูกยกเลิก + %1$d / 2 ตำแหน่งข้อมือ Joy-Con วัดด้วยระบบสเตอริโอ + ฝ่ามือที่ติดตาม: %1$d / 2; พร้อมใช้ท่าจีบนิ้ว: %2$d; พร้อมใช้ท่ากำมือ: %3$d + บันทึกการจับเพื่อวินิจฉัยไปที่ %1$s + การติดตามมือหยุดลง: %1$s + สเตอริโอ %1$d×%2$d; %3$s + การติดตามศีรษะและเป้าหมายการปรับเทียบไม่ตรงกันภายใน %1$s (จำกัด 5 ซม. / 2 นิ้ว) รักษาเป้าหมายการสอบเทียบให้คงที่และรอการติดตามอย่างคงที่ก่อนที่จะเริ่มชุดใหม่ หมุนและเอียงแว่นตาอัจฉริยะเบาๆ หยุดชั่วคราวก่อนการถ่ายภาพแต่ละครั้ง + จับภาพมุมมองที่แตกต่างกันอย่างน้อย 24 มุมมองของเป้าหมายการสอบเทียบที่อยู่นิ่ง + หมุนแว่นตาอัจฉริยะไปทางซ้ายและขวา แล้วเอียงขึ้นและลง การเคลื่อนไหวโดยไม่มีการหมุนไม่สามารถปรับเทียบการจัดตำแหน่งกล้องได้ + พื้นฐานกล้องที่ไม่น่าเชื่อ + ขยับศีรษะไปตามทิศทางที่หลากหลายมากขึ้น + การหมุนกล้องต่อศีรษะไม่ถูกต้อง + การจัดตำแหน่งกล้องกับศีรษะไม่สอดคล้องกัน + การปรับเทียบไม่สามารถเสร็จสิ้นได้ %1$s มุมมองที่บันทึกไว้ของคุณจะถูกบันทึกไว้ + ข้อผิดพลาดในการฉายซ้ำที่จัดขึ้น %1$.2f px เกิน 2 px ปรับเทียบใหม่ + %1$d / ตรวจพบมุมกระดานหมากรุก 24 มุมในกล้องทั้งสองตัว ให้มองเห็นเป้าหมายการสอบเทียบแบบเต็มและค้างไว้นิ่งๆ หากมองเห็นได้อยู่แล้ว ให้เลือก 12 นิ้วหรือ 30 ซม. แล้ววัดระยะห่างที่ใกล้กว่านั้นก่อนลองอีกครั้ง + สามารถมองเห็นเป้าหมายการปรับเทียบได้ แต่ไม่สามารถวัดความลึกได้อย่างน่าเชื่อถือ จับแว่นตาอัจฉริยะให้นิ่ง และรักษาเป้าหมายการปรับเทียบให้เรียบและมีแสงสว่างเพียงพอ จากนั้นลองอีกครั้ง + การวัดของกล้องไม่ถูกต้อง ให้นิ่งไว้แล้วลองอีกครั้ง + ผ่านการตรวจสอบระยะทางแล้ว + ตรวจสอบระยะห่างจากกล้องด้านซ้ายไปยังศูนย์กลางเป้าหมายการสอบเทียบอีกครั้ง จากนั้นลองอีกครั้ง + กล้องวัดได้ %1$s; ระยะทางที่เลือก %2$s %3$s + รอให้แสดงตัวอย่างกล้องทั้งสองตัวก่อนเริ่มการปรับเทียบ + มุมมองที่บันทึกไว้สามารถคำนวณใหม่ได้ เริ่มการสอบเทียบใหม่เพื่อบันทึกในระบบพิกัดการติดตามปัจจุบัน + ผลรวมตรวจสอบแบบจำลองมือไม่ตรงกัน + OpenCV ไม่สามารถโหลดได้ + กู้คืนมุมมองที่บันทึกไว้แล้ว %1$d รายการ คำนวณการสอบเทียบเพื่อลองอีกครั้ง หรือเริ่มชุดใหม่เพื่อบันทึกข้อมูลเพิ่มเติม diff --git a/app/src/main/res/values-tr/strings.xml b/app/src/main/res/values-tr/strings.xml index 4273df1ff4..3322f1c92a 100644 --- a/app/src/main/res/values-tr/strings.xml +++ b/app/src/main/res/values-tr/strings.xml @@ -2352,14 +2352,14 @@ Ekran Yenileme hızı 3D (yan yana) - Her göz 3840×1080 görüntünün kendi yarısını alır. Görüntü kesilirse gözlüğün 2D/3D düğmesini basılı tutun. + Akıllı gözlükleri yan yana 3B\'ye geçirin. Baş takibi ayrı olarak kontrol edilir. 3D sinyali doğrulanamadı. 2D görüntü geri geldiğinde tekrar deneyin. Görüntü yok: gözlük bu telefonun gönderemediği bir modda. Gözlüğün 2D/3D düğmesini basılı tutun ya da kablosunu çıkarıp yeniden takın. 3D yenileme hızı VR oyunlarında 3D SteamVR çalışırken 3D\'ye geçer, sonra geri döner. - 3D görüntü - Otomatik: SteamVR görüşü doldurur; diğer oyunlar 3D\'de bir ekran olarak havada durur, 2D\'de düz kalır. + Resim + Otomatik mod, düz içeriği her iki göze de gösterir ve SteamVR’ı algılar. SBS içeriği için Yan yana oyun seçeneğini seçin. Otomatik Sanal ekran Yan yana oyun @@ -2369,20 +2369,20 @@ Bu ayarlar, “Oyun gözlükte” açıkken ve oyun orada gösterilirken geçerlidir. Otomatik, bu 2D oyunu tam ekran tutar. Genişliğini, uzaklığını ve kafa takibini ayarlamak için sanal ekran kullanın. Sanal ekranı kullan - SteamVR görüşü doldurur. Görüş alanını aşağıdan ayarlayın; genişlik ve uzaklık yalnızca sanal ekranda geçerlidir. + SteamVR görünümü doldurur. VR\'da görüş alanını ayarlayın; genişlik ve mesafe yalnızca sanal ekrana uygulanır. Yan yana oyunlar her gözü doldurur. Genişlik ve uzaklık yalnızca sanal ekranda geçerlidir. Otomatik, bu 2D oyunu görüşte sabit tutar. Kafa takibini kullanmak için “Ekran” bölümünde “Sanal ekran” seçeneğine geçin. Kafa takibi, sanal ekranda veya çalışan bir SteamVR oyununda geçerlidir. - Gözlük + Cihaz Parlaklık Ses düzeyi Güneş koruması Ön camları karartır. - Kafa takibi + İzleme Kafa takibi Gözlüğün kendi sensörleri sanal ekranı ve SteamVR\'ı başınızla birlikte döndürür. Görünümü ortala - Ortala + Ekranı yeniden ortala SteamVR görüş alanı Düşük değer SteamVR\'ı yaklaştırır ve gözlüğü doldurur; yüksek değer çevrenizi daha çok gösterir. %1$s ile oynanıyor @@ -2403,8 +2403,8 @@ Kayıtlı kalibrasyon kaldırılsın ve model varsayılanları geri yüklensin mi? Gözlüğü yeniden taktıktan sonra ortalayın. Sıfırla El takibi - Elleriniz kamerayla takip edilsin mi? - Kamera ellerinizi görebilir. Bağlı bir kumanda yokken çıplak elleriniz VR elleri olur: tıklamak için başparmağınızla işaret parmağınızı birleştirin, tutmak için elinizi yumruk yapın, menüyü açmak için de avucunuzu kendinize çevirip parmaklarınızı birleştirin. Joy-Con\'larla kamera onları ellerinizin gerçekten bulunduğu yere yerleştirir. Görüntüler bu cihazda işlenir, asla kaydedilmez veya gönderilmez. + Telefon kamerasıyla elleri veya Joy-Con kumandalarını takip etme? + Bağlı bir kumanda yokken, telefon kamerası VR\'da çıplak ellerinizi takip eder: tıklamak için baş parmağınızı ve işaret parmağınızı sıkıştırın, kavramak için elinizi kapatın ve menüyü açmak için avucunuzu kendinize doğru çevirin ve sıkıştırın. Eşleştirilmiş Joy-Con kumandalarıyla, kamera konumlarını takip ederken Joy-Con kumandaları döndürme ve düğme girişleri sağlar. Resimler bu cihazda işlenir ve asla kaydedilmez veya gönderilmez. Arka kamera Önerilir. Genellikle daha net ve daha geniş. Ön kamera @@ -2412,7 +2412,7 @@ Kamerayı kullan Şimdi değil Kamerayla el takibi - Bağlı bir kumanda yokken elleriniz VR elleri olur: tıklamak için parmaklarınızı birleştirin, menü için avucunuzu kendinize çevirip birleştirin. Joy-Con\'larla onları kameranın gördüğü yere yerleştirir. Görüntüler bu cihazda kalır. + Çıplak el hareketleri için veya VR\'da eşleştirilmiş Joy-Con kumandalarını konumlandırmak için telefon kamerasını kullanın. Joy-Con kumandaları döndürme ve düğme girişleri sağlar. Akıllı gözlükler ellerinizi veya Joy-Con kumandalarınızı izlerken duraklatır. Görüntüler yalnızca bu cihazda işlenir. Kamera Kamera erişimi El takibinin başlayabilmesi için kamera erişimine izin verin. @@ -2680,4 +2680,208 @@ %1$s Steam için dönüştürülüyor. DroidDeck\'i açık tut. Bu cihaz o videonun kodunu çözemiyor. Video içe aktarılamadı + Luma Ultra kameralar — Deneysel + Joy-Con konum takibi + Eşleştirilmiş Joy-Con kumandalarınızı konumlandırmak için akıllı gözlük kameralarını kullanın. Döndürme ve düğme girişleri Joy-Con kumandalarından gelir. Bilekleriniz gizlendiğinde konum tahmin edilir. Çıplak elle çalıştırılan kumandaların yerini alır ve telefon kamerası izlemesini duraklatır. İzleme merkezini bağlarken veya sıfırlarken Joy-Con kumandalarını ileriye doğru çevirin. + Önce konum takibini etkinleştirin. Android 12 veya üzeri sürümlerde hareket algılama özelliğine sahip Joy-Con kumandaları gerektirir. Varsayılan olarak kapalıdır. + Akıllı gözlükler + Ekran ve baş izleme ayarları DroidDeck menüleri, oyunlar ve masaüstü oturumları arasında paylaşılır. + Ekran ve izleme ayarlarını değiştirmek için akıllı gözlükleri bağlayın. Bağlantıyı kestiğinizde kaydedilmiş ayarlarınız korunur. + VR + Görüntüleme modu + 2B çıktı + 3B çıktı + Resim ve sanal ekran + Konum ve zemin seviyesi + El takibi — Deneysel + Takip durumu + 2B çözünürlük + 3B çözünürlük + VR çözünürlük + Otomatik + 2B / 3B ile aynı + Göz başına çıktı çözünürlüğü. + Ekranın yerel 30 Hz modunu seçmek için Akıllı gözlüklerde Oyun özelliğini etkinleştirin. + 3DoF sanal ekran + Etrafınıza bakabilmeniz için düz oyunları önünüze sabitleyin. 3B\'ye geçmeden Akıllı gözlüklerde Oyun özelliğini etkinleştirir. + Genişlik ve mesafe, DroidDeck menüleri, oyunları ve masaüstü oturumları için izlenen sanal ekranı anında günceller. + Konumsal izleme, SteamVR\'da baş döndürmeyi içerir. Yalnızca döndürme izleme için konumsal izlemeyi kapatın. + Sanal ekranda baş hareketini kontrol eder. Konumsal izleme, SteamVR\'da baş döndürmeyi içerir. + Hızlı işlemler + Ekranın nerede olmasını istediğinize bakın, ardından yüksekliğini ve yönünü ayarlamak için izleme merkezini sıfırlayın. + Joy-Con cihazlarını yeniden ortala + Telefon kamerası — Deneysel + Elleri veya Joy-Con kumandalarını takip etme + 6DoF sanal ekran + Konumsal izleme — deneysel + VR\'da ve sanal ekranlar etrafında fiziksel hareket. İzlemeyi yeniden başlatmak biraz zaman alır. + Zeminden mevcut göz yüksekliği + Mevcut yükseklikten zemin seviyesini ayarlayın + Zemin seviyesini ayarlayın + Stereo kamera kurulumu ve teşhis + Oynamadan önce kamera kalibrasyonunu ve ellerin izlenmesini kontrol edin. + Kurulumu açın + Çıplak elle kullanılan kumandalar + VR\'da ellerinizle nişan almak, tıklamak için sıkıştırmak ve yakalamak için elinizi kapatmak için akıllı gözlük kameralarını kullanın. Oyun kumandası çubukları hareket eder ve döner. Joy-Con konum izlemesinin yerini alır. Oyunlar sırasında gecikme yaşanabilir veya izleme kaybolabilir. + İzleme bölümünde Luma Ultra kameraları altında çıplak elle kullanılan kumandaları etkinleştirin. Önce açık elleri gösterin. + Paylaşılan Luma Ultra kalibrasyonu + Paylaşılan Luma Ultra tabanını kullanma. Doğruluğunu doğrulamak için kendi akıllı gözlüklerinizi kalibre edin. + Ölçülen kalibrasyon doğrulandı + Doğrulama gerekli + Ölçülen mesafe kontrolü geçtikten sonra çıplak elle çalıştırılan kumandalar kullanılabilir hale gelir. + İzleme kayboldu + Hala takılıp kaldınız mı? Telefonunuzda: akıllı gözlük → İzleme → Kurulumu aç → Tanılamayı göster → İzlemeyi yeniden başlatın. + Akıllı gözlük bağlantısı kesildi + USB bağlantısını kontrol edin ve akıllı gözlükleri yeniden bağlayın.\nTelefonunuzda USB erişim istemi belirirse, kabul edin. + Bağlandıktan sonra, izlemeyi yeniden başlatmak için iyi aydınlatılmış bir odada yavaşça etrafınıza bakın. + Yeniden ortalama gerekli + İzleme yeni bir konumda geri döndü.\nİleriye bakın, ardından telefonunuzda izleme merkezini sıfırla seçeneğine dokunun. + İzleme merkezini sıfırlama seçeneğini akıllı gözlükler → İzleme → Kurulumu aç bölümünde de bulabilirsiniz. Kaydedilen kamera kalibrasyonunuz korunur. + Bir an hareketsiz dur + İzleme merkezi sıfırlama işlemi devam ediyor.\nİzleme sabitlenirken akıllı gözlükleri sabit tutun. + Kafa takibi hazır olduğunda bu ekran otomatik olarak kapanır. + Ellerle stabilize nişan alma + Omzunuzdan avucunuzun içine doğru nişan alın. Bilek kontrollü dönüş için kapatın. + Uzamsal kurulum + Takip bekleniyor… + Sol ve sağ izleme kameraları + Kamera senkronizasyonu + Hazır + Kamera ve kafa takibinin hizalanması bekleniyor. Akıllı gözlükleri bağlı tutun. + 1. Kalibrasyon hedefini hazırlayın + Gerçek boyutta yazdır + Her karenin ölçüsü 30 mm (1,181 inç) olmalıdır. Levhayı iyi aydınlatılmış bir alanda sert bir yüzeye düz olarak monte edin. + Kalibrasyon desenini yazdır + 2. Farklı görünümler yakalayın + Kalibrasyon hedefini sabit tutun + Akıllı gözlükleri yaklaştırın, uzaklaştırın ve yanlara doğru hareket ettirin. Bunları sola/sağa çevirin, yukarı/aşağı açı verin ve yanlara doğru eğin. Kalibrasyon hedefini her iki kamerada da tutun ve her çekimden önce kısa bir süre duraklayın. + Yeni kalibrasyonu başlat + Kamera senkronizasyonu bekleniyor. + Görünümleri toplamak için yeni bir kalibrasyon başlatın. + Kalibrasyon hedefini her iki önizlemede de görünür tutun. Farklı açılardan en az 24 keskin görüntü yakalayın. + Yakalanıyor… + Kalibrasyon hedefi görünümünü yakala + Kamera hizalamasını hesapla + Hesaplanıyor… + Kalibrasyonu hesapla + 3. Mesafeyi kontrol edin + Ölçülen mesafe + Yazdırılan işaretlerin daha kolay algılanması için 12 inç veya 30 cm ile başlayın. Kullanacağınız tam ölçümü seçin. + Sol kamera kalibrasyon hedefinin merkezine + Mesafe kontrol ediliyor… + Mesafeyi doğrula + Teşhis + Tanılamayı göster + Kamera zamanlaması ve izleme kurtarma araçları. + Kamera zamanlaması + Ellerin takibinden gelen girdi + Kamera zamanlaması bekleniyor. + Kamera görüntüleri + Ellerin GPU tespiti + CPU varsayılandır. GPU deneyseldir ve SteamVR\'nin yeniden başlatılmasına neden olabilir. İzleme yeniden başlatıldığında bu seçim sıfırlanır. + El modellerinin Lite tespiti + Lite avuç içi dedektörünü ve ellerdeki Lite anahtar noktalarını kullanın. Nişan alma, sıkıştırma ve yakalama doğruluğunu kontrol edin. İzleme yeniden başlatıldığında sıfırlanır. + Ellerin takibi için otomatik giriş frekansı + Girişi işlem hızına ayarlayın. İzleme yeniden başlatıldığında sıfırlanır. + Ellerin takibi için giriş frekansını sınırlayın + Kamera görüntülerinin yarısını kullanın. Maksimum frekansı karşılaştırmak için kapatın. İzleme yeniden başlatıldığında sıfırlanır. + Tanısal yakalama + Bir stereo görüntü çiftini yerel olarak kaydedin. Resimler yalnızca istendiğinde kaydedilir. + Kamera görüntüsünü kaydet + Takibi yeniden başlat + İyi aydınlatılmış bir alanda izleme düzelmezse kullanın. Yeniden başlatma, yeni bir izleme kaynağı gerektirir. + Yeniden başlat + İzleme yeniden başlatılsın mı? + Kaydedilmemiş kalibrasyon görüntüleri kaybolacaktır. Daha sonra akıllı gözlükleri sabit tutun ve izleme geri yüklendiğinde izleme merkezini sıfırlayın. + %1$d / 24 görüntüleme yakalandı + Yakalama duraklatıldı: %1$s + Ölçün %1$s. Kalibrasyon hedefinin tamamını her iki önizlemede de gösterin ve ardından sabit tutun. + %1$.1f Hz • görüntü yaşı %2$.1f ms • işleme %3$.1f ms + Kamera görüntülerinin giriş sınırı %1$.1f Hz • %2$.0f%%. Kafa takibi maksimum frekansında devam eder. + %1$d işlendi • %2$d bırakıldı • %3$d giriş sınırına göre atlandı + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra kalibrasyonu + 100% / Gerçek boyutta yazdırın. Her kare: 30 mm (1,181 inç). + Kalibrasyon hedefini düz ve sabit tutun; akıllı gözlükleri çekimler arasında hareket ettirin. + Ölçek kontrolü: İşaretler arasında 100 mm (3,937 inç) + 12 inç (30,48 cm) + 30 cm (11,81 inç) + 20 inç (50,8 cm) + 50 cm (19,69 inç) + Devre Dışı + Kararlı izleme bekleniyor + Bağlantı kesildi + Çıplak elle çalıştırılan denetleyiciler kapalı + Konumsal izleme kapalı veya akıllı gözlüklerin bağlantısı kesilmiş + İzleme merkezi sıfırlama isteği - izleme sabitlenirken sabit tutun + Takip kaybı — görünür ayrıntılara sahip, iyi aydınlatılmış bir alanla yüzleşin + İzleme orijini değişti - izleme merkezini sıfırla\'ya dokunun, ardından sabit tutun + 6DoF aktif + Luma Ultra\'yı bağlayın ve konumsal izlemeyi etkinleştirin. + Bu bağlantı için kalibrasyon doğrulandı. + Kalibrasyon doğrulandı ve kaydedildi. + Stereo kameralar bekleniyor + Ellerin takibi bekleniyor + 5 × 7 kalibrasyon hedefini sabit tutun. Akıllı gözlükleri hareket ettirirken ve döndürürken 24\'ten fazla görüntü yakalayın. + Sonraki kamera görüntüsü bekleniyor. Akıllı gözlüğü sabit tutun. + Sonraki kamera görüntüsü kontrol ediliyor. Tam kalibrasyon hedefini görünür tutun ve sabit tutun. + Önce kalibrasyonu başlatın + Yeni kamera görüntüsü gelmedi. Akıllı gözlük bağlantısını ve kamera önizlemelerini kontrol edip tekrar deneyin. + Kamera saatini sıfırlama + İzleme koordinat sistemi değişti. Görüntüleriniz yeniden hesaplama için kaydedildi. İzleme merkezini sıfırlayın, ardından daha fazla görüntü yakalamak için yeni bir set başlatın. + cihaz kalibrasyonu yüklendi + Luma Ultra temel kalibrasyonu yüklendi + kalibrasyon gerekli + Önce yeni kalibrasyonu başlat\'a dokunun. + İzleme merkezi sıfırlama, sabit izlemeyi bekliyor. Bir an için sabit tutun. + İzleme değişti. Yakalamadan önce izleme merkezini sıfırla\'ya bir kez dokunun, ardından sabit tutun. + Yakalama reddedildi: Baş takibi yakalama sırasında senkronize değildi veya değişti. Hareketsiz kal ve tekrar dene. + Mesafeyi kontrol etmeden önce kamera hizalamasını hesaplayın. + kamera işleme başarısız oldu + Ellerin tespiti sırasında kafa takibi değişti + Kamera ve kafa senkronizasyonu bekleniyor + Bilek algılanmadı. Joy-Con kumandanızın tutacaklarını akıllı gözlüğün önünde tutun + El algılanmadı. Akıllı gözlüklerin önünde açık avuç içi göster + Bilekler yalnızca bir kamerada görünüyor; denetleyici tutamaçlarınızı paylaşılan görünümde tutun + Eller yalnızca bir kamerada görünüyor; her iki avucunuzu da paylaşılan görünümde tutun + Her iki kamera da elleri görüyor ancak sol/sağ eşleşmesi belirsiz + Eller algılandı ancak stereo derinliği tutarsız + Bilek konumu stereo veya hareket kontrolleri tarafından reddedildi + Stereo noktalar algılandı ancak avuç içi geometrisi tutarsız + Elleri etkinleştirmek için kalibrasyonu ve mesafe kontrolünü tamamlayın + Sabit kafa izlemesi bekleniyor; istenirse izleme merkezini sıfırlayın + Kamera gözlemi çok eski; yeni bir çift bekliyorum + %1$.2f piksele sığdır. Sol kameradan kalibrasyon hedef merkezine kadar seçtiğiniz mesafeyi ölçün ve ardından doğrulayın. + OpenCV kullanılamıyor: %1$s + %1$d kayıtlı görünüm geri yüklendi. Yeniden denemek için kalibrasyonu hesaplayın veya daha fazlasını yakalamak için yeni bir set başlatın. + Yakalandı %1$d / 24 görüntüleme. Kalibrasyon hedefini sabit tutun; Bir sonraki görünüm için akıllı gözlükleri hareket ettirin. + Yakalama reddedildi: %1$d / 12 gerekli köşe her iki kamerada da görünüyor. Kalibrasyon hedefinin daha fazlasını gösterin, sabit durun ve tekrar deneyin. + Mesafe kontrolü tamamlanamadı: %1$s. Tekrar deneyin. + Ellerin algılanması kullanılamıyor: %1$s. Yeniden denemek için CPU/GPU\'yu değiştirin veya çıplak elle çalıştırılan denetleyicileri değiştirin. + Ellerin tespiti %1$d ms\'yi aştı; gözlem atıldı + %1$d / 2 Joy-Con bilek konumu stereo ile ölçüldü + İzlenen avuç içi: %1$d / 2; çimdik hareketi hazır: %2$d; kavrama hareketi hazır: %3$d + Teşhis yakalaması %1$s\'a kaydedildi + Ellerin takibi durduruldu: %1$s + Stereo %1$d×%2$d; %3$s + Kafa takibi ve kalibrasyon hedefi %1$s (sınır 5 cm / 2 inç) kadar uyuşmuyor. Kalibrasyon hedefini sabit tutun ve yeni bir sete başlamadan önce istikrarlı izlemeyi bekleyin. Akıllı gözlükleri yavaşça çevirin ve eğin; her yakalamadan önce duraklatın. + Mantıksız kamera temel çizgisi + Başınızı daha çeşitli yönlere doğru hareket ettirin. + Geçersiz kamera-kafa dönüşü + Kamera-kafa hizalaması tutarsız. + Kalibrasyon tamamlanamadı. %1$s Yakalanan görünümleriniz kaydedilir. + Bekletilen yeniden projeksiyon hatası %1$.2f piksel, 2 pikseli aşıyor. Yeniden kalibre edin. + %1$d / Her iki kamerada da 24 dama tahtası köşesi algılandı. Tam kalibrasyon hedefini görünür tutun ve sabit tutun. Zaten görünüyorsa, 12 inç veya 30 cm\'yi seçin ve tekrar denemeden önce bu yakın mesafeyi ölçün. + Kalibrasyon hedefi görünür ancak derinliği güvenilir bir şekilde ölçülemedi. Akıllı gözlüğü sabit tutun ve kalibrasyon hedefini düz ve iyi aydınlatılmış halde tutun, ardından yeniden deneyin. + Kamera ölçümü geçersizdi. Kımıldama ve tekrar dene. + Mesafe kontrolü başarılı oldu. + Sol kamera ile kalibrasyon hedefinin merkezi arasındaki mesafeyi yeniden kontrol edin ve ardından yeniden deneyin. + Kameralar ölçüldü %1$s; seçilen mesafe %2$s. %3$s + Kalibrasyona başlamadan önce her iki kamera önizlemesini bekleyin. + Kaydedilen görünümler yeniden hesaplanabilir. Geçerli izleme koordinat sistemini yakalamak için yeni bir kalibrasyon başlatın. + El modeli sağlama toplamı uyuşmazlığı + OpenCV yüklenemedi + İyi aydınlatılmış bir odada yavaşça etrafa bakın.\nİzleme kameralarını temiz tutun ve mobilyalara veya diğer görünür ayrıntılara doğru bakın. + Sabit kalibrasyon hedefinin en az 24 farklı görünümünü yakalayın. + Akıllı gözlükleri sola ve sağa çevirin, yukarı ve aşağı eğin; dönme olmadan hareket, kamera hizalamasını kalibre edemez. diff --git a/app/src/main/res/values-uk/strings.xml b/app/src/main/res/values-uk/strings.xml index 6e305d204f..fb30a8e4e3 100644 --- a/app/src/main/res/values-uk/strings.xml +++ b/app/src/main/res/values-uk/strings.xml @@ -2416,14 +2416,14 @@ Екран Частота оновлення 3D (стереопара) - Кожне око отримує свою половину зображення 3840×1080. Якщо зображення зникне, утримуйте кнопку 2D/3D на окулярах. + Перемикайте смарт-окуляри в режим 3D поруч. Відстеження голови контролюється окремо. Сигнал 3D не підтверджено. Спробуйте знову, коли повернеться зображення 2D. Немає зображення: окуляри в режимі, який цей телефон не може передати. Утримуйте їхню кнопку 2D/3D або від’єднайте й знову під’єднайте їх. Частота оновлення в 3D 3D для VR-ігор Перемикає на 3D, поки працює SteamVR, а потім назад. - Зображення 3D - Автоматично: SteamVR заповнює поле зору; інші ігри висять як екран у 3D і лишаються пласкими у 2D. + Зображення + Автоматично відображає плоский контент для обох очей та виявляє SteamVR. Виберіть «Гра поруч» для контенту SBS. Автоматично Віртуальний екран Стереопара з гри @@ -2433,20 +2433,20 @@ Ці налаштування діють, коли ввімкнено «Гра на окулярах» і гра показується на них. «Автоматично» показує цю 2D-гру на весь екран. Щоб налаштувати її ширину, відстань і відстеження голови, використайте віртуальний екран. Використати віртуальний екран - SteamVR заповнює все зображення. Налаштуйте поле зору нижче; ширина й відстань стосуються лише віртуального екрана. + SteamVR заповнює поле зору. Налаштуйте поле зору у VR; ширина та відстань застосовуються лише до віртуального екрана. Ігри зі стереопарою займають усе поле зору кожного ока. Ширина й відстань стосуються лише віртуального екрана. «Автоматично» тримає цю 2D-гру нерухомою в полі зору. Щоб використовувати відстеження голови, виберіть «Віртуальний екран» у розділі «Екран». Відстеження голови діє для віртуального екрана або запущеної гри SteamVR. - Окуляри + Пристрій Яскравість Гучність Затемнення Затемнює передні лінзи. - Відстеження голови + Відстеження Відстеження голови Власні датчики окулярів повертають віртуальний екран і SteamVR услід за головою. Відцентрувати вигляд - Відцентрувати + Повторно центрувати екран Поле зору SteamVR Нижче значення наближає SteamVR і заповнює окуляри; вище — показує більше навколо вас. Гра на %1$s @@ -2467,8 +2467,8 @@ Видалити збережене калібрування й відновити стандартні значення моделі? Відцентруйте вигляд, коли знову надінете окуляри. Скинути Відстеження рук - Відстежувати руки за допомогою камери? - Камера бачить ваші руки. Якщо контролер не підключено, ваші руки самі стають руками у VR: зведіть великий і вказівний пальці, щоб натиснути, стисніть кулак, щоб схопити, а щоб відкрити меню, поверніть долоню до себе й зведіть пальці. З Joy-Con камера розташовує їх там, де насправді перебувають ваші руки. Зображення обробляються на цьому пристрої і ніколи не зберігаються та не надсилаються. + Відстежувати руки або контролери Joy-Con за допомогою камери телефону? + Якщо контролер не підключено, камера телефону відстежує ваші руки голими руками у VR: зведіть великий та вказівний пальці, щоб клацнути, стисніть руку, щоб схопити, та поверніть долоню до себе та зведіть, щоб відкрити меню. Зі сполученими контролерами Joy-Con камера відстежує їхнє положення, тоді як контролери Joy-Con забезпечують обертання та натискання кнопок. Зображення обробляються на цьому пристрої та ніколи не зберігаються та не надсилаються. Задня камера Рекомендовано. Зазвичай різкіша і ширша. Фронтальна камера @@ -2476,7 +2476,7 @@ Використати камеру Не зараз Відстеження рук камерою - Якщо контролер не підключено, ваші руки стають руками у VR: зведіть пальці, щоб натиснути, а повернувши долоню до себе, — щоб відкрити меню. З Joy-Con розташовує їх там, де їх бачить камера. Зображення залишаються на цьому пристрої. + Використовуйте камеру телефону для жестів голими руками або для розташування парних контролерів Joy-Con у віртуальній реальності. Контролери Joy-Con забезпечують обертання та введення кнопок. Призупиняється, поки розумні окуляри відстежують ваші руки або контролери Joy-Con. Зображення обробляються лише на цьому пристрої. Камера Доступ до камери Дозвольте доступ до камери, щоб розпочати відстеження рук. @@ -2748,4 +2748,208 @@ %1$s перетворюється для Steam. Не закривайте DroidDeck. Пристрій не може декодувати це відео. Не вдалося імпортувати відео + Камери Luma Ultra — Експериментально + Відстеження положення Joy-Con + Використовуйте камери розумних окулярів, щоб розташувати парні контролери Joy-Con. Обертання та введення кнопок надходять від контролерів Joy-Con. Положення оцінюється, коли ваші зап\'ястя приховані. Замінює контролери, якими керують голими руками, та призупиняє відстеження камерою телефону. Направте контролери Joy-Con вперед під час підключення або скидання центру відстеження. + Спочатку ввімкніть відстеження положення. Потрібні контролери Joy-Con з функцією руху на Android 12 або пізнішої версії. Вимкнено за замовчуванням. + Розумні окуляри + Налаштування дисплея та відстеження голови спільні для меню DroidDeck, ігор та сеансів робочого столу. + Підключіть розумні окуляри, щоб змінити їх налаштування дисплея та відстеження. Ваші збережені налаштування зберігаються після відключення. + VR + Режим відображення + Вихід 2D + Вихід 3D + Зображення та віртуальний екран + Положення та рівень підлоги + Відстеження рук — Експериментально + Стан відстеження + Роздільна здатність 2D + Роздільна здатність 3D + Роздільна здатність VR + Автоматично + Те саме, що 2D / 3D + Роздільна здатність виходу для кожного ока. + Увімкніть «Гра на смарт-окулярах», щоб вибрати власний режим дисплея 30 Гц. + Віртуальний екран 3DoF + Закріпіть плоскі ігри перед собою, щоб ви могли дивитися навколо. Увімкне «Гра на смарт-окулярах» без перемикання в 3D. + Ширина та відстань миттєво оновлюють відстежуваний віртуальний екран для меню DroidDeck, ігор та сеансів робочого столу. + Відстеження позиції включає обертання голови у SteamVR. Для відстеження лише обертання вимкніть відстеження позиції. + Керує рухом голови на віртуальному екрані. Відстеження позиції включає обертання голови у SteamVR. + Швидкі дії + Подивіться, куди ви хочете розмістити екран, а потім скиньте центр відстеження, щоб встановити його висоту та напрямок. + Повторно центрувати Joy-Con + Камера телефону — Експериментальна функція + Відстежувати руки або контролери Joy-Con + Віртуальний екран 6DoF + Відстеження позиції — експериментальна функція + Фізичний рух у VR та навколо віртуальних екранів. Перезапуск відстеження займає деякий час. + Поточна висота очей над підлогою + Встановити рівень підлоги з поточної висоти + Встановити рівень підлоги + Налаштування та діагностика стереокамери + Перевірте калібрування камери та відстеження рук перед грою. + Відкрити налаштування + Контролери, що працюють голими руками + Використовуйте камери розумних окулярів для прицілювання руками, щіпніть, щоб клацнути, та стисніть руку, щоб захопити у VR. Геймпади рухаються та повертаються. Замінює відстеження положення Joy-Con. Може затримуватися або втрачатися відстеження під час ігор. + Увімкніть контролери, що працюють голими руками, під камерами Luma Ultra у режимі відстеження. Спочатку покажіть відкриті руки. + Спільне калібрування Luma Ultra + Використання спільної бази Luma Ultra. Калібруйте власні розумні окуляри, щоб перевірити їхню точність. + Виміряне калібрування перевірено + Потрібна перевірка + Контролери, що працюють голими руками, стають доступними після проходження перевірки виміряної відстані. + Втрачено відстеження + Повільно озирніться навколо в добре освітленій кімнаті.\nТримайте камери відстеження чистими та повертайте їх до меблів або інших видимих ​​деталей. + Все ще застрягли? На вашому телефоні: розумні окуляри → Відстеження → Відкрити налаштування → Показати діагностику → Перезапустити відстеження. + Смарт-окуляри від’єднано + Перевірте USB-з’єднання та знову підключіть розумні окуляри.\nПрийміть підказку USB-доступу на телефоні, якщо вона з’явиться. + Після підключення повільно озирніться в добре освітленій кімнаті, щоб відновити відстеження. + Потрібне повторне центрування + Відстеження повернулося в нове положення.\nПодивіться вперед, а потім натисніть \"скинути центр відстеження\" на телефоні. + Ви також можете знайти опцію скидання центру відстеження в розділі «Смарт-окуляри» → «Відстеження» → «Відкрити налаштування». Збережене калібрування камери зберігається. + Затримайтеся на мить + Триває скидання центру відстеження.\nТримайте смарт-окуляри нерухомо, поки відстеження стабілізується. + Цей екран автоматично закривається, коли відстеження голови готове. + Стабілізоване прицілювання руками + Цілься від плеча через долоню. Вимкніть для керування обертанням зап’ястя. + Просторові налаштування + Очікування відстеження… + Ліва та права камери стеження + Синхронізація камери + Готовий + Очікування камери та відстеження голови на одну лінію. Тримайте розумні окуляри підключеними. + 1. Підготуйте мішень для калібрування + Роздрукувати в реальному розмірі + Кожен квадрат має мати розмір 30 мм (1,181 дюйма). Встановіть лист рівно на тверду поверхню в добре освітленому місці. + Надрукувати калібрувальну мішень + 2. Знімайте різні види + Тримайте калібрувальну мішень нерухомо + Пересувайте розумні окуляри ближче, далі та вбік. Повертайте їх ліворуч/праворуч, нахиляйте вгору/вниз і нахиляйте вбік. Тримайте калібрувальну мішень в обох камерах і робіть коротку паузу перед кожним знімком. + Розпочати нове калібрування + Очікування синхронізації камери. + Розпочніть нове калібрування для збору переглядів. + Зберігайте калібрувальну ціль видимою в обох попередніх переглядах. Зробіть щонайменше 24 різких кадри з різних кутів. + Захоплення… + Захоплення виду калібрування + Розрахувати вирівнювання камери + Обчислення… + Розрахувати калібрування + 3. Перевірте відстань + Виміряна відстань + Почніть із 12 дюймів або 30 см, щоб надруковані маркери було легше виявити. Виберіть точне вимірювання, яке ви будете використовувати. + Ліва камера до центру калібрувальної мішені + Перевірка відстані… + Перевірка відстані + Діагностика + Показати діагностику + Інструменти відновлення синхронізації камери та відстеження. + Хронометраж камери + Вхід із відстеження рук + Очікування часу камери. + Зображення камери + GPU виявлення рук + Полегшене визначення моделей рук + Використовуйте детектор долоні Lite і ключові точки Lite на руках. Перевірте точність прицілювання, щипка та захоплення. Скидається під час перезапуску відстеження. + Автоматична вхідна частота для відстеження рук + Налаштування введення відповідно до швидкості обробки. Скидається під час перезапуску відстеження. + Обмеження частоти введення для відстеження рук + Використовуйте половину зображень камери. Вимкніть, щоб порівняти максимальну частоту. Скидається під час перезапуску відстеження. + Діагностичне захоплення + Збережіть одну пару стереозображень локально. Зображення зберігаються лише за запитом. + Зберегти зображення камери + Відновити відстеження + Використовуйте, якщо відстеження не відновлюється в добре освітленому місці. Перезапуск вимагає нового джерела відстеження. + Перезапустити + Відновити відстеження? + Незбережені калібрувальні зображення будуть втрачені. Після цього тримайте смарт-окуляри нерухомо та скиньте центр відстеження, коли відстеження відновиться. + %1$d / Зафіксовано 24 перегляди + Запис призупинено: %1$s + Міра %1$s. Покажіть повну ціль калібрування в обох попередніх переглядах, а потім затримайтеся. + %1$.1f Гц • вік зображення %2$.1f мс • обробка %3$.1f мс + Вхідний ліміт %1$.1f Гц • %2$.0f%% зображень камери. Відстеження голови продовжується на максимальній частоті. + %1$d оброблено • %2$d видалено • %3$d пропущено обмеженням введення + DroidDeck ChArUco 30 mm + DroidDeck – калібрування Luma Ultra + Друк на 100% / Реальний розмір. Кожен квадрат: 30 мм (1,181 дюйма). + Тримайте калібрувальну мішень рівною та нерухомою; переміщайте розумні окуляри між знімками. + Перевірка масштабу: 100 мм (3,937 дюйма) між позначками + 12 дюймів (30,48 см) + 30 см (11,81 дюйма) + 20 дюймів (50,8 см) + 50 см (19,69 дюйма) + Вимкнено + Очікування стабільного відстеження + Відключено + Контролери, якими керують голими руками, вимкнені + Відстеження позиції вимкнено або розумні окуляри від’єднано + Запит на скидання центру відстеження — тримайте нерухомо, поки відстеження стабілізується. + Відстеження втрачено — обличчям до добре освітленої області з видимими деталями + Початок відстеження змінено — натисніть «Скинути центр відстеження», а потім тримайте нерухомо. + 6DoF активний + Підключіть Luma Ultra та ввімкніть відстеження позиції. + Калібрування перевірено для цього підключення. + Калібрування перевірено та збережено. + Очікування стереокамер + Очікування відстеження рук + Тримайте калібрувальну мішень 5 × 7 нерухомо. Робіть понад 24 перегляди, переміщаючи та обертаючи розумні окуляри. + Очікування наступного зображення камери. Тримайте розумні окуляри нерухомо. + Перевірка наступного зображення камери. Тримайте повну калібрувальну мішень видимою та тримайтеся нерухомо. + Спочатку почніть калібрування + Нове зображення камери не надійшло. Перевірте підключення розумних окулярів і попередній перегляд камери, а потім повторіть спробу. + Скидання годинника камери + Система координат відстеження змінена. Ваші зображення зберігаються для перерахунку. Скиньте центр відстеження, а потім почніть новий набір, щоб захопити більше зображень. + завантажено калібрування пристрою + Базове калібрування Luma Ultra завантажено + потрібне калібрування + Торкніться «Спочатку почати нове калібрування». + Центр скидання відстеження очікує на стабільне відстеження. Затримайтеся нерухомо на мить. + Відстеження змінено. Натисніть «Скинути центр відстеження» один раз, а потім тримайте нерухомо перед зйомкою. + Знімок відхилено: відстеження голови не було синхронізоване або змінилося під час зйомки. Не рухайтеся та спробуйте ще раз. + Розрахуйте вирівнювання камери перед перевіркою відстані. + Помилка обробки камери + Відстеження голови змінено під час виявлення рук + Очікування синхронізації камери та голови + Зап\'ястя не виявлено. Тримайте ручки контролера Joy-Con перед розумними окулярами + Руки не виявлено. Покажіть відкриті долоні перед розумними окулярами + Зап’ястя видно лише в одній камері; тримайте ручки контролера в спільному поданні + Руки видно лише в одній камері; тримайте обидві долоні в загальному вигляді + Обидві камери бачать руки, але відповідність ліворуч/праворуч неоднозначна + Руки виявлено, але стереоглибина неузгоджена + Положення зап’ястя відхилено стереосистемою чи перевіркою руху + Виявлено стереоточки, але геометрія долоні суперечлива + Завершіть калібрування та перевірте відстань, щоб увімкнути руки + Очікування стабільного відстеження голови; скиньте центр відстеження, якщо запитується. + Камера спостереження занадто стара; в очікуванні свіжої пари + Розмістити %1$.2f пікс. Виміряйте вибрану відстань від лівої камери до центру калібрувальної мішені, а потім перевірте. + OpenCV недоступний: %1$s + %1$d збережені перегляди відновлено. Обчисліть калібрування, щоб повторити спробу, або почніть новий набір, щоб отримати більше. + Знято %1$d / 24 перегляди. Тримайте цілі калібрування фіксованими; перемістіть розумні окуляри для наступного перегляду. + Зйомку відхилено: %1$d / 12 необхідних кутів видно в обох камерах. Покажіть більше калібрувальної мішені, затримайтеся та повторіть спробу. + Не вдалося завершити перевірку відстані: %1$s. Спробуйте знову. + Виявлення рук недоступні: %1$s. Змініть CPU/GPU або перемкніть контролери, якими керуєте голими руками, щоб повторити спробу. + Виявлення рук перевищило %1$d мс; спостереження відхилено + %1$d / 2 позиції зап’ястя Joy-Con, виміряні стереосистемою + Відстежувані долоні: %1$d / 2; готовність до щипка: %2$d; готовність до захоплення: %3$d + Діагностичний запис збережено в %1$s + Відстеження рук припинено: %1$s + Стерео %1$d×%2$d; %3$s + Відстеження голови та ціль калібрування не збігаються на %1$s (обмеження 5 см / 2 дюйми). Зберігайте ціль калібрування фіксованою та дочекайтеся стабільного відстеження перед початком нового набору. Обережно повертайте та нахиляйте розумні окуляри; пауза перед кожним захопленням. + Зробіть принаймні 24 різноманітні види стаціонарної мішені для калібрування. + Повертайте розумні окуляри ліворуч і праворуч, нахиляйте їх угору та вниз; рух без обертання не може відкалібрувати вирівнювання камери. + Неправдоподібна базова лінія камери + Рухайте головою в різних положеннях. + Недійсне обертання камери до голови + Вирівнювання камери до голови невідповідне. + Не вдалося завершити калібрування. %1$s Ваші захоплені види збережено. + Помилка повторної проекції %1$.2f пікселів перевищує 2 пікселі. Перекалібруйте. + %1$d / 24 кути шахової дошки виявлено в обох камерах. Тримайте повну калібрувальну мішень видимою та тримайтеся нерухомо. Якщо його вже видно, виберіть 12 дюймів або 30 см і виміряйте ближчу відстань перед повторною спробою. + Мішень для калібрування видно, але її глибину не можна достовірно виміряти. Тримайте розумні окуляри нерухомо та тримайте калібрувальну мішень рівною та добре освітленою, а потім повторіть спробу. + Вимірювання камери недійсне. Затримайтеся та спробуйте ще раз. + Перевірку дистанції пройдено. + Повторно перевірте відстань від лівої камери до центру калібрувальної мішені та повторіть спробу. + Виміряно камерами %1$s; вибрана відстань %2$s. %3$s + Перед початком калібрування зачекайте на попередній перегляд обох камер. + Збережені перегляди можна перерахувати. Розпочніть нове калібрування для запису в поточній системі координат відстеження. + Невідповідність контрольної суми моделі руки + Не вдалося завантажити OpenCV + Типово використовується CPU. Режим GPU є експериментальним і може спричинити перезапуск SteamVR. Вибір скидається після перезапуску відстеження. diff --git a/app/src/main/res/values-vi/strings.xml b/app/src/main/res/values-vi/strings.xml index 6551b2fff2..05ff91a856 100644 --- a/app/src/main/res/values-vi/strings.xml +++ b/app/src/main/res/values-vi/strings.xml @@ -2341,14 +2341,14 @@ Hiển thị Tốc độ làm mới 3D (cạnh nhau) - Mỗi mắt nhận một nửa riêng của hình 3840×1080. Nếu mất hình, hãy giữ nút 2D/3D của kính. + Chuyển kính thông minh sang chế độ 3D song song. Chức năng theo dõi đầu được điều khiển riêng. Chưa xác nhận được tín hiệu 3D. Hãy thử lại khi hình ảnh 2D trở lại. Không có hình: kính đang ở chế độ mà điện thoại này không thể xuất. Hãy giữ nút 2D/3D của kính, hoặc rút ra rồi cắm lại. Tốc độ làm mới 3D 3D cho game VR Chuyển sang 3D khi SteamVR chạy, rồi chuyển lại sau đó. - Hình ảnh 3D - Tự động: SteamVR lấp đầy tầm nhìn; các game khác hiện như một màn hình lơ lửng ở 3D và giữ phẳng ở 2D. + Hình ảnh + Tự động hiển thị nội dung phẳng ở cả hai mắt và phát hiện SteamVR. Chọn trò chơi Song song cho nội dung SBS. Tự động Màn hình ảo Game 3D cạnh nhau @@ -2358,20 +2358,20 @@ Các thiết lập này áp dụng khi “Game trên kính” đang bật và game đang hiển thị trên kính. Tự động giữ game 2D này ở chế độ toàn màn hình. Dùng màn hình ảo để chỉnh chiều rộng, khoảng cách và theo dõi đầu. Dùng màn hình ảo - SteamVR lấp đầy tầm nhìn. Chỉnh trường nhìn ở bên dưới; chiều rộng và khoảng cách chỉ áp dụng cho màn hình ảo. + SteamVR lấp đầy tầm nhìn. Điều chỉnh trường nhìn của nó trong VR; chiều rộng và khoảng cách chỉ áp dụng cho màn hình ảo. Game 3D cạnh nhau lấp đầy từng mắt. Chiều rộng và khoảng cách chỉ áp dụng cho màn hình ảo. Tự động giữ game 2D này cố định trong tầm nhìn. Chọn “Màn hình ảo” trong “Hiển thị” để dùng theo dõi đầu. Theo dõi đầu áp dụng cho màn hình ảo hoặc game SteamVR đang chạy. - Kính + Thiết bị Độ sáng Âm lượng Chống nắng Làm tối tròng kính phía trước. - Theo dõi đầu + Theo dõi Theo dõi đầu Cảm biến riêng của kính xoay màn hình ảo và SteamVR theo đầu bạn. Căn giữa lại góc nhìn - Căn giữa lại + Căn giữa lại màn hình Trường nhìn của SteamVR Thấp hơn sẽ đưa SteamVR lại gần và lấp đầy kính; cao hơn cho thấy nhiều hơn xung quanh bạn. Đang chơi trên %1$s @@ -2392,8 +2392,8 @@ Xóa hiệu chỉnh đã lưu và khôi phục mặc định của mẫu kính? Hãy căn giữa lại sau khi đeo kính vào. Đặt lại Theo dõi tay - Theo dõi tay của bạn bằng camera? - Camera có thể thấy tay bạn. Khi không kết nối tay cầm nào, đôi tay trần của bạn sẽ trở thành tay trong VR: chụm ngón cái và ngón trỏ để nhấp, nắm tay lại để cầm, và xoay lòng bàn tay về phía bạn rồi chụm ngón tay để mở menu. Khi dùng Joy-Con, camera đặt chúng đúng nơi tay bạn thực sự ở. Hình ảnh được xử lý ngay trên thiết bị này và không bao giờ được lưu hay gửi đi. + Theo dõi tay hoặc bộ điều khiển Joy-Con bằng camera điện thoại? + Khi không có bộ điều khiển nào được kết nối, camera điện thoại sẽ theo dõi bàn tay trần của bạn trong VR: chụm ngón cái và ngón trỏ để nhấp, khép bàn tay để cầm, và xoay lòng bàn tay về phía bạn và chụm để mở menu. Với bộ điều khiển Joy-Con được ghép nối, camera sẽ theo dõi vị trí của chúng trong khi bộ điều khiển Joy-Con cung cấp khả năng xoay và nhập nút. Hình ảnh được xử lý trên thiết bị này và không bao giờ được lưu hoặc gửi đi. Camera sau Nên dùng. Thường sắc nét và có góc nhìn rộng hơn. Camera trước @@ -2401,7 +2401,7 @@ Dùng camera Không phải bây giờ Theo dõi tay bằng camera - Khi không kết nối tay cầm nào, tay bạn sẽ trở thành tay trong VR: chụm ngón tay để nhấp, lòng bàn tay hướng về bạn và chụm ngón để mở menu. Khi dùng Joy-Con, chúng được đặt đúng vị trí camera nhìn thấy. Hình ảnh luôn ở lại trên thiết bị này. + Sử dụng camera điện thoại để thực hiện các cử chỉ bằng tay không hoặc để định vị bộ điều khiển Joy-Con đã ghép nối trong VR. Bộ điều khiển Joy-Con cung cấp khả năng xoay và nhập nút. Tạm dừng trong khi kính thông minh theo dõi tay hoặc bộ điều khiển Joy-Con của bạn. Hình ảnh chỉ được xử lý trên thiết bị này. Camera Quyền camera Hãy cho phép quyền camera để bắt đầu theo dõi tay. @@ -2655,4 +2655,208 @@ Đang chuyển đổi %1$s cho Steam. Hãy để DroidDeck mở. Thiết bị này không giải mã được video đó. Không thể nhập video này + Camera Luma Ultra — Thử nghiệm + Theo dõi vị trí Joy-Con + Sử dụng camera của kính thông minh để định vị bộ điều khiển Joy-Con đã ghép nối. Xoay và nhập nút đến từ bộ điều khiển Joy-Con. Vị trí được ước tính khi cổ tay của bạn bị che khuất. Thay thế bộ điều khiển được điều khiển bằng tay không và tạm dừng theo dõi bằng camera điện thoại. Hướng bộ điều khiển Joy-Con về phía trước khi kết nối hoặc đặt lại trung tâm theo dõi. + Trước tiên hãy bật tính năng theo dõi vị trí. Yêu cầu bộ điều khiển Joy-Con có khả năng chuyển động trên Android 12 trở lên. Mặc định là tắt. + Kính thông minh + Cài đặt hiển thị và theo dõi đầu được chia sẻ trên các menu, trò chơi và phiên máy tính để bàn của DroidDeck. + Kết nối kính thông minh để thay đổi cài đặt hiển thị và theo dõi của chúng. Các cài đặt đã lưu của bạn sẽ được giữ lại khi bạn ngắt kết nối. + Thực tế ảo (VR) + Chế độ hiển thị + Đầu ra 2D + Đầu ra 3D + Hình ảnh và màn hình ảo + Vị trí và độ cao sàn + Theo dõi tay — Thử nghiệm + Trạng thái theo dõi + Độ phân giải 2D + Độ phân giải 3D + Độ phân giải VR + Tự động + Giống như 2D / 3D + Độ phân giải đầu ra cho mỗi mắt. + Bật Chơi game trên kính thông minh để chọn chế độ 30 Hz gốc của màn hình. + Màn hình ảo 3DoF + Neo các trò chơi phẳng trước mặt bạn để bạn có thể nhìn xung quanh. Cho phép Chơi game trên kính thông minh mà không cần chuyển sang 3D. + Chiều rộng và khoảng cách cập nhật màn hình ảo được theo dõi cho menu, trò chơi và phiên máy tính để bàn của DroidDeck ngay lập tức. + Theo dõi vị trí bao gồm xoay đầu trong SteamVR. Để chỉ theo dõi xoay, hãy tắt theo dõi vị trí. + Điều khiển chuyển động đầu trên màn hình ảo. Theo dõi vị trí bao gồm xoay đầu trong SteamVR. + Thao tác nhanh + Nhìn vào vị trí bạn muốn màn hình, sau đó đặt lại trung tâm theo dõi để thiết lập chiều cao và hướng của nó. + Căn giữa lại Joy-Con + Camera điện thoại — Thử nghiệm + Theo dõi tay hoặc bộ điều khiển Joy-Con + Màn hình ảo 6DoF + Theo dõi vị trí — thử nghiệm + Chuyển động vật lý trong VR và xung quanh màn hình ảo. Khởi động lại theo dõi mất một chút thời gian. + Chiều cao mắt hiện tại so với sàn nhà + Đặt mức sàn từ chiều cao hiện tại + Đặt mức sàn + Thiết lập và chẩn đoán camera stereo + Kiểm tra hiệu chuẩn camera và theo dõi tay trước khi chơi. + Mở thiết lập + Bộ điều khiển được vận hành bằng tay trần + Sử dụng camera kính thông minh để nhắm mục tiêu bằng tay, chụm để nhấp và khép tay để nắm trong VR. Cần điều khiển của gamepad di chuyển và xoay. Thay thế tính năng theo dõi vị trí của Joy-Con. Có thể bị lag hoặc mất theo dõi trong khi chơi game. + Cho phép bộ điều khiển được vận hành bằng tay trần dưới camera Luma Ultra trong phần Theo dõi. Hiển thị bàn tay mở trước. + Hiệu chuẩn Luma Ultra dùng chung + Sử dụng cơ sở Luma Ultra dùng chung. Hiệu chuẩn kính thông minh của riêng bạn để xác minh độ chính xác của chúng. + Đã xác minh hiệu chuẩn đo được + Cần xác thực + Bộ điều khiển được vận hành bằng tay trần sẽ khả dụng sau khi kiểm tra khoảng cách đo được hoàn tất. + Mất theo dõi + Vẫn còn mắc kẹt? Trên điện thoại của bạn: kính thông minh → Theo dõi → Mở thiết lập → Hiển thị chẩn đoán → Khởi động lại theo dõi. + Kính thông minh bị ngắt kết nối + Kiểm tra kết nối USB và kết nối lại kính thông minh.\nChấp nhận lời nhắc truy cập USB trên điện thoại của bạn nếu nó xuất hiện. + Sau khi kết nối, hãy từ từ nhìn xung quanh trong phòng có đủ ánh sáng để khôi phục tính năng theo dõi. + Cần căn giữa lại + Quá trình theo dõi đã trở lại ở vị trí mới.\nNhìn về phía trước, sau đó chạm vào đặt lại trung tâm theo dõi trên điện thoại của bạn. + Bạn cũng có thể tìm thấy tùy chọn đặt lại trung tâm theo dõi trong kính thông minh → Theo dõi → Mở thiết lập. Hiệu chuẩn camera đã lưu của bạn sẽ được giữ nguyên. + Giữ yên một lát + Quá trình đặt lại trung tâm theo dõi đang diễn ra.\nGiữ kính thông minh ổn định trong khi quá trình theo dõi ổn định. + Màn hình này tự động đóng khi tính năng theo dõi đầu đã sẵn sàng. + Ổn định mục tiêu bằng tay + Nhắm từ vai qua lòng bàn tay của bạn. Tắt để xoay điều khiển bằng cổ tay. + Thiết lập không gian + Đang chờ theo dõi… + Camera theo dõi trái và phải + Đồng bộ hóa máy ảnh + Sẵn sàng + Đang chờ camera và theo dõi đầu xếp hàng. Giữ kính thông minh được kết nối. + 1. Chuẩn bị mục tiêu hiệu chuẩn + In ở kích thước thực tế + Mỗi hình vuông phải có kích thước 30 mm (1,181 in). Đặt tấm phẳng trên bề mặt cứng ở khu vực có nhiều ánh sáng. + In bảng hiệu chuẩn + 2. Chụp các góc nhìn khác nhau + Giữ mục tiêu hiệu chuẩn cố định + Di chuyển kính thông minh lại gần, xa hơn và sang một bên. Xoay chúng sang trái/phải, nghiêng chúng lên/xuống và nghiêng chúng sang một bên. Giữ mục tiêu hiệu chỉnh trong cả hai máy ảnh và tạm dừng một thời gian ngắn trước mỗi lần chụp. + Bắt đầu hiệu chuẩn mới + Đang chờ đồng bộ hóa camera. + Bắt đầu hiệu chỉnh mới để thu thập lượt xem. + Giữ mục tiêu hiệu chỉnh hiển thị trong cả hai bản xem trước. Chụp ít nhất 24 góc nhìn sắc nét từ các góc khác nhau. + Đang nắm bắt… + Chụp ảnh mục tiêu hiệu chỉnh + Tính toán căn chỉnh camera + Đang tính… + Tính toán hiệu chuẩn + 3. Kiểm tra khoảng cách + Khoảng cách đo được + Bắt đầu với 12 inch hoặc 30 cm để các điểm đánh dấu được in dễ phát hiện hơn. Chọn phép đo chính xác mà bạn sẽ sử dụng. + Camera trái đến trung tâm mục tiêu hiệu chỉnh + Đang kiểm tra khoảng cách… + Xác thực khoảng cách + Chẩn đoán + Hiển thị chẩn đoán + Công cụ phục hồi theo dõi và định giờ của máy ảnh. + Thời gian của máy ảnh + Đầu vào từ theo dõi bàn tay + Đang chờ thời gian của máy ảnh. + Hình ảnh máy ảnh + GPU phát hiện bàn tay + CPU là mặc định. GPU đang ở giai đoạn thử nghiệm và có thể khiến SteamVR khởi động lại. Lựa chọn này sẽ đặt lại khi quá trình theo dõi khởi động lại. + Phát hiện mẫu bàn tay nhẹ nhàng + Sử dụng bộ dò tìm lòng bàn tay Lite và các điểm chính Lite trên bàn tay. Kiểm tra độ chính xác của việc nhắm, chụm và lấy. Đặt lại khi theo dõi khởi động lại. + Tần số đầu vào tự động để theo dõi bàn tay + Điều chỉnh đầu vào theo tốc độ xử lý. Đặt lại khi theo dõi khởi động lại. + Giới hạn tần số đầu vào để theo dõi bàn tay + Sử dụng một nửa số hình ảnh của camera. Tắt để so sánh tần số tối đa. Đặt lại khi theo dõi khởi động lại. + Chụp chẩn đoán + Lưu cục bộ một cặp hình ảnh nổi. Hình ảnh chỉ được lưu khi được yêu cầu. + Lưu hình ảnh camera + Khởi động lại theo dõi + Sử dụng nếu việc theo dõi không phục hồi ở khu vực có đủ ánh sáng. Việc khởi động lại yêu cầu nguồn gốc theo dõi mới. + Khởi động lại + Khởi động lại theo dõi? + Các chế độ xem hiệu chuẩn chưa được lưu sẽ bị mất. Sau đó, giữ kính thông minh yên và đặt lại trung tâm theo dõi khi quá trình theo dõi được khôi phục. + %1$d / 24 lượt xem được chụp + Đã tạm dừng chụp: %1$s + Biện pháp %1$s. Hiển thị mục tiêu hiệu chỉnh hoàn chỉnh trong cả hai bản xem trước, sau đó giữ yên. + %1$.1f Hz • tuổi hình ảnh %2$.1f ms • xử lý %3$.1f ms + Giới hạn đầu vào %1$.1f Hz • %2$.0f%% hình ảnh camera. Theo dõi đầu tiếp tục ở tần số tối đa. + %1$d đã xử lý • %2$d bị loại bỏ • %3$d bị bỏ qua theo giới hạn đầu vào + DroidDeck ChArUco 30 mm + DroidDeck - Hiệu chuẩn Luma Ultra + In ở tỷ lệ 100% / Kích thước thực tế. Mỗi hình vuông: 30 mm (1,181 in). + Giữ mục tiêu hiệu chỉnh bằng phẳng và cố định; di chuyển kính thông minh giữa các lần chụp. + Kiểm tra tỷ lệ: 100 mm (3,937 in) giữa các dấu tích + 12 inch (30,48 cm) + 30 cm (11,81 inch) + 20 inch (50,8 cm) + 50 cm (19,69 in) + Vô hiệu hóa + Đang chờ theo dõi ổn định + Đã ngắt kết nối + Bộ điều khiển được vận hành bằng tay trần đã tắt + Tính năng theo dõi vị trí bị tắt hoặc kính thông minh bị ngắt kết nối + Yêu cầu đặt lại trung tâm theo dõi — giữ yên trong khi quá trình theo dõi ổn định + Mất dấu vết — đối mặt với khu vực đủ ánh sáng với chi tiết rõ ràng + Gốc theo dõi đã thay đổi — chạm vào đặt lại trung tâm theo dõi, sau đó giữ yên + 6DoF hoạt động + Kết nối Luma Ultra và bật theo dõi vị trí. + Đã xác minh hiệu chuẩn cho kết nối này. + Đã xác minh và lưu hiệu chuẩn. + Đang chờ camera lập thể + Chờ theo dõi bàn tay + Giữ mục tiêu hiệu chỉnh 5 × 7 cố định. Chụp hơn 24 góc nhìn trong khi di chuyển và xoay kính thông minh. + Đang chờ hình ảnh camera tiếp theo. Giữ yên kính thông minh. + Kiểm tra hình ảnh camera tiếp theo. Giữ mục tiêu hiệu chỉnh đầy đủ hiển thị và giữ yên. + Bắt đầu hiệu chỉnh trước + Không có hình ảnh máy ảnh mới nào được gửi đến. Hãy kiểm tra kết nối của kính thông minh và các bản xem trước của máy ảnh, sau đó thử lại. + Đặt lại đồng hồ máy ảnh + Hệ tọa độ theo dõi đã thay đổi. Các chế độ xem của bạn được lưu để tính toán lại. Đặt lại trung tâm theo dõi, sau đó bắt đầu một bộ mới để chụp thêm chế độ xem. + đã tải hiệu chuẩn thiết bị + Đã tải hiệu chuẩn cơ sở Luma Ultra + cần hiệu chuẩn + Trước tiên hãy nhấn vào Bắt đầu hiệu chuẩn mới. + Đang chờ theo dõi ổn định. Giữ yên trong giây lát. + Quá trình theo dõi đã thay đổi. Chạm vào đặt lại trung tâm theo dõi một lần, sau đó giữ yên trước khi chụp. + Không thể chụp: tính năng theo dõi đầu chưa đồng bộ hoặc đã thay đổi trong khi chụp. Giữ yên và thử lại. + Tính toán căn chỉnh camera trước khi kiểm tra khoảng cách. + xử lý máy ảnh không thành công + Tính năng theo dõi đầu đã thay đổi trong quá trình phát hiện bàn tay + Đang chờ đồng bộ hóa camera và đầu + Không phát hiện thấy cổ tay. Giữ tay cầm điều khiển Joy-Con của bạn ở phía trước kính thông minh + Không phát hiện thấy bàn tay nào. Hiển thị lòng bàn tay mở trước kính thông minh + Chỉ có thể nhìn thấy cổ tay trong một camera; giữ các tay cầm điều khiển của bạn ở chế độ xem chung + Chỉ nhìn thấy bàn tay trong một camera; giữ cả hai lòng bàn tay trong chế độ xem chung + Cả hai camera đều nhìn thấy bàn tay, nhưng việc khớp trái/phải không rõ ràng + Đã phát hiện thấy bàn tay nhưng độ sâu lập thể không nhất quán + Vị trí cổ tay bị từ chối bởi kiểm tra lập thể hoặc chuyển động + Đã phát hiện thấy các điểm nổi, nhưng hình dạng lòng bàn tay không nhất quán + Hoàn tất hiệu chỉnh và kiểm tra khoảng cách để kích hoạt tay + Đang chờ theo dõi đầu ổn định; đặt lại trung tâm theo dõi nếu được yêu cầu + Camera quan sát quá cũ; đang chờ một cặp mới + Vừa vặn %1$.2f px. Đo khoảng cách đã chọn của bạn từ camera bên trái đến trung tâm mục tiêu hiệu chỉnh, sau đó xác thực. + OpenCV không có sẵn: %1$s + %1$d lượt xem đã lưu được khôi phục. Tính toán hiệu chuẩn để thử lại hoặc bắt đầu một bộ mới để thu được nhiều dữ liệu hơn. + Đã chụp được %1$d / 24 lượt xem. Giữ mục tiêu hiệu chuẩn cố định; di chuyển kính thông minh để xem tiếp theo. + Ảnh chụp bị từ chối: %1$d / 12 góc bắt buộc hiển thị ở cả hai máy ảnh. Hiển thị thêm mục tiêu hiệu chỉnh, giữ yên rồi thử lại. + Kiểm tra khoảng cách không thể hoàn thành: %1$s. Hãy thử lại. + Không thể phát hiện bàn tay: %1$s. Thay đổi CPU/GPU hoặc bộ điều khiển chuyển đổi được vận hành bằng tay trần để thử lại. + Phát hiện bàn tay vượt quá %1$d ms; quan sát bị loại bỏ + %1$d/2 vị trí cổ tay Joy-Con được đo bằng lập thể + Lòng bàn tay được theo dõi: %1$d / 2; sẵn sàng chụm ngón: %2$d; sẵn sàng nắm: %3$d + Đã lưu bản chụp chẩn đoán vào %1$s + Đã ngừng theo dõi bàn tay: %1$s + Lập thể %1$d×%2$d; %3$s + Theo dõi đầu và mục tiêu hiệu chỉnh không đồng nhất ở mức %1$s (giới hạn 5 cm / 2 in). Giữ mục tiêu hiệu chuẩn cố định và chờ theo dõi ổn định trước khi bắt đầu thiết lập mới. Xoay và nghiêng kính thông minh một cách nhẹ nhàng; tạm dừng trước mỗi lần chụp. + Chụp ít nhất 24 góc nhìn khác nhau của mục tiêu hiệu chỉnh cố định. + Xoay kính thông minh sang trái và phải và nghiêng lên xuống; chuyển động không xoay không thể hiệu chỉnh căn chỉnh camera. + Đường cơ sở máy ảnh đáng kinh ngạc + Di chuyển đầu của bạn theo nhiều hướng khác nhau. + Xoay camera đối đầu không hợp lệ + Căn chỉnh giữa máy ảnh và đầu không nhất quán. + Hiệu chỉnh không thể hoàn tất. %1$s Chế độ xem đã chụp của bạn sẽ được lưu. + Lỗi chiếu lại bị giữ lại %1$.2f px vượt quá 2 px. Hiệu chỉnh lại. + %1$d / Đã phát hiện 24 góc bàn cờ ở cả hai máy ảnh. Giữ mục tiêu hiệu chỉnh đầy đủ hiển thị và giữ yên. Nếu nó đã hiển thị, hãy chọn 12 inch hoặc 30 cm và đo khoảng cách gần hơn đó trước khi thử lại. + Mục tiêu hiệu chuẩn có thể nhìn thấy được nhưng độ sâu của nó không thể đo được một cách đáng tin cậy. Giữ cố định kính thông minh và giữ mục tiêu hiệu chỉnh bằng phẳng và đủ ánh sáng, sau đó thử lại. + Phép đo của camera không hợp lệ. Giữ yên và thử lại. + Đã vượt qua kiểm tra khoảng cách. + Kiểm tra lại khoảng cách từ máy ảnh bên trái đến tâm mục tiêu hiệu chỉnh, sau đó thử lại. + Máy ảnh đo được %1$s; khoảng cách đã chọn %2$s. %3$s + Đợi cả hai bản xem trước của máy ảnh trước khi bắt đầu hiệu chỉnh. + Các lượt xem đã lưu có thể được tính toán lại. Bắt đầu hiệu chuẩn mới để chụp trong hệ tọa độ theo dõi hiện tại. + Tổng kiểm tra mô hình bàn tay không khớp + OpenCV không thể tải + Nhìn xung quanh chậm rãi trong phòng có đủ ánh sáng.\nGiữ cho camera theo dõi rõ ràng và hướng về phía đồ nội thất hoặc các chi tiết có thể nhìn thấy khác. diff --git a/app/src/main/res/values-zh-rCN/strings.xml b/app/src/main/res/values-zh-rCN/strings.xml index 6a0b5b8ee8..c0acbc7785 100644 --- a/app/src/main/res/values-zh-rCN/strings.xml +++ b/app/src/main/res/values-zh-rCN/strings.xml @@ -2341,14 +2341,14 @@ 显示 刷新率 3D(左右分屏) - 每只眼睛各看 3840×1080 画面的一半。如果画面消失,请长按眼镜上的 2D/3D 按钮。 + 将智能眼镜切换至并排 3D 模式。头部追踪单独控制。 未能确认 3D 信号。请在 2D 画面恢复后重试。 无画面:眼镜处于这部手机无法输出的模式。请长按眼镜的 2D/3D 按钮,或拔下后重新连接。 3D 刷新率 VR 游戏使用 3D SteamVR 运行时切换到 3D,结束后切回。 - 3D 画面 - 自动:SteamVR 填满视野;其他游戏在 3D 下以屏幕形式悬浮,在 2D 下保持平面。 + 图片 + 自动模式会在双眼显示平面内容并检测 SteamVR。选择“并排游戏”模式可显示 SBS 内容。 自动 虚拟屏幕 左右分屏游戏 @@ -2358,20 +2358,20 @@ 这些设置在开启“在眼镜上显示游戏”且游戏显示在眼镜上时生效。 “自动”会让这款 2D 游戏全屏显示。使用虚拟屏幕可调整其宽度、距离和头部追踪。 使用虚拟屏幕 - SteamVR 会填满视野。可在下方调整其视场角;宽度和距离仅适用于虚拟屏幕。 + SteamVR 会充满整个视野。在 VR 中调整其视野范围;宽度和距离仅适用于虚拟屏幕。 左右分屏游戏会填满每只眼睛的视野。宽度和距离仅适用于虚拟屏幕。 “自动”会让这款 2D 游戏固定在视野中。要使用头部追踪,请在“显示”中选择“虚拟屏幕”。 头部追踪适用于虚拟屏幕或正在运行的 SteamVR 游戏。 - 眼镜 + 设备 亮度 音量 遮光 让前镜片变暗。 - 头部追踪 + 追踪 头部追踪 眼镜自带的传感器会随头部转动虚拟屏幕和 SteamVR。 重新居中视角 - 重新居中 + 重置屏幕中心 SteamVR 视场角 调低让 SteamVR 更近并填满眼镜;调高可看到更多周围内容。 正在 %1$s 上游玩 @@ -2392,8 +2392,8 @@ 删除已保存的校准并恢复该型号的默认值?重新戴上眼镜后请重新居中。 重置 手部追踪 - 要用相机追踪你的双手吗? - 相机能看到你的双手。未连接手柄时,你的双手会直接成为 VR 中的手:拇指和食指捏合即可点击,握拳即可抓取,掌心朝向自己再捏合即可打开菜单。使用 Joy-Con 时,会把它们放在你双手的实际位置。画面在本设备上处理,绝不会被保存或发送。 + 使用手机摄像头追踪手部或 Joy-Con 控制器? + 未连接控制器时,手机摄像头会在 VR 中追踪您的裸手:拇指和食指捏合即可点击,握紧拳头即可抓取,掌心朝向自己并捏合即可打开菜单。连接 Joy-Con 控制器后,摄像头会追踪其位置,同时 Joy-Con 控制器会提供旋转和按键输入。照片会在本设备上处理,不会保存或发送。 后置相机 推荐使用。通常更清晰、视野更广。 前置相机 @@ -2401,7 +2401,7 @@ 使用相机 暂不 相机手部追踪 - 未连接手柄时,你的双手会成为 VR 中的手:捏合即可点击,掌心朝向自己再捏合即可打开菜单。使用 Joy-Con 时,会将其放在相机看到的位置。画面不会离开本设备。 + 使用手机摄像头进行徒手手势操作或在 VR 中定位已配对的 Joy-Con 控制器。Joy-Con 控制器提供旋转和按键输入。当智能眼镜追踪您的手或 Joy-Con 控制器时,此功能会暂停。图像仅在此设备上处理。 相机 相机权限 请允许相机权限,以便开始手部追踪。 @@ -2655,4 +2655,208 @@ 正在为 Steam 转换 %1$s。请保持 DroidDeck 打开。 此设备无法解码该视频。 无法导入该视频 + Luma Ultra 摄像头 — 实验性功能 + Joy-Con 位置追踪 + 使用智能眼镜摄像头定位已配对的 Joy-Con 控制器。旋转和按键输入来自 Joy-Con 控制器。当您的手腕被遮挡时,系统会估算位置。此功能会取代徒手操作的控制器,并暂停手机摄像头追踪。连接或重置追踪中心时,请将 Joy-Con 控制器指向前方。 + 请先启用位置追踪功能。需要 Android 12 或更高版本且 Joy-Con 控制器支持体感功能。默认关闭。 + 智能眼镜 + 显示和头部追踪设置可在 DroidDeck 菜单、游戏和桌面会话之间共享。 + 连接智能眼镜以更改其显示和追踪设置。断开连接后,您保存的设置将被保留。 + VR + 显示模式 + 2D 输出 + 3D 输出 + 画面和虚拟屏幕 + 位置和地面高度 + 手部追踪 — 实验性功能 + 追踪状态 + 2D 分辨率 + 3D 分辨率 + VR 分辨率 + 自动 + 与 2D / 3D 相同 + 单眼输出分辨率 + 启用智能眼镜游戏功能,选择显示器的原生 30 Hz 模式。 + 3DoF 虚拟屏幕 + 将平面游戏固定在您面前,以便您可以环顾四周。无需切换到 3D 模式即可启用智能眼镜游戏功能。 + 宽度和距离会立即更新 DroidDeck 菜单、游戏和桌面会话的追踪虚拟屏幕。 + 位置追踪包含 SteamVR 中的头部旋转。如需仅进行旋转追踪,请关闭位置追踪。 + 控制虚拟屏幕上的头部移动。位置追踪包含 SteamVR 中的头部旋转。 + 快捷操作 + 看向您希望屏幕显示的位置,然后重置追踪中心以设置其高度和方向。 + 重置 Joy-Con 中心 + 手机摄像头 — 实验性功能 + 追踪手部或 Joy-Con 控制器 + 位置追踪 — 实验性功能 + 在VR中以及虚拟屏幕周围进行物理移动。重新开始追踪需要一些时间。 + 当前眼睛距地面的高度 + 根据当前高度设置地面高度 + 设置地面高度 + 立体摄像头设置和诊断 + 游戏前检查摄像头校准和手部追踪。 + 打开设置 + 用手操作控制器 + 使用智能眼镜摄像头用手瞄准,捏合点击,握紧手掌抓取VR中的物品。游戏手柄摇杆可以移动和旋转。取代Joy-Con的位置追踪。游戏过程中可能会出现延迟或追踪丢失。 + 在追踪设置中,启用Luma Ultra摄像头下的徒手操作控制器。首先显示张开的手。 + 共享Luma Ultra校准 + 使用共享的Luma Ultra底座。校准您的智能眼镜以验证其准确性。 + 测量校准已验证 + 需要验证 + 通过测量距离检查后,即可使用裸手操作控制器。 + 追踪丢失 + 还卡住了吗?在手机上:智能眼镜→跟踪→打开设置→显示诊断→重新启动跟踪。 + 智能眼镜断开连接 + 检查 USB 连接并重新连接智能眼镜。\n如果手机上出现 USB 访问提示,请接受该提示。 + 连接后,在光线充足的房间中慢慢环顾四周以恢复跟踪。 + 需要重置中心 + 追踪已恢复到新位置。\n看向前方,然后在手机上点击“重置追踪中心”。 + 您也可以在智能眼镜 → 追踪 → 打开设置中找到重置追踪中心。您保存的相机校准信息将被保留。 + 稍等一下 + 重置追踪中心正在进行中。\n请在追踪稳定期间保持智能眼镜静止。 + 当头部跟踪准备就绪时,该屏幕自动关闭。 + 稳定双手瞄准 + 从肩膀到手掌瞄准。关闭以进行手腕控制旋转。 + 空间设置 + 等待追踪…… + 左、右跟踪摄像机 + 相机同步 + 准备好了 + 等待相机和头部跟踪对齐。保持智能眼镜连接。 + 1.准备校准目标 + 按实际尺寸打印 + 每个正方形的尺寸必须为 30 毫米(1.181 英寸)。将板材平坦地安装在光线充足区域的刚性表面上。 + 打印校准板 + 2.捕捉不同的观点 + 保持校准目标静止 + 将智能眼镜移近、移远和侧向移动。向左/向右转动它们,向上/向下倾斜它们,并向侧面倾斜它们。将校准目标保留在两个相机中,并在每次捕获之前短暂暂停。 + 开始新的校准 + 等待相机同步。 + 开始新的校准以收集视图。 + 保持校准目标在两个预览中可见。从不同角度捕捉至少 24 个清晰视图。 + 捕捉…… + 捕获校准目标视图 + 计算相机对准 + 正在计算…… + 计算校准 + 3.检查距离 + 测量距离 + 从 12 英寸或 30 厘米开始,以便打印的标记更容易检测到。选择您将使用的精确测量值。 + 左相机至标定目标中心 + 检查距离…… + 验证距离 + 诊断 + 显示诊断 + 相机定时和跟踪恢复工具。 + 相机计时 + 来自手部跟踪的输入 + 等待相机计时。 + 相机图像 + GPU检测手部 + CPU 是默认值。 GPU 是实验性的,可能会导致 SteamVR 重新启动。当跟踪重新启动时,此选择会重置。 + 手部模型的精简检测 + 使用 Lite 手掌检测器和手上的 Lite 关键点。检查瞄准、捏合和抓取的准确性。跟踪重新启动时重置。 + 自动输入频率以跟踪手部 + 调整输入处理速度。跟踪重新启动时重置。 + 限制手部追踪的输入频率 + 使用一半的相机图像。关闭以比较最大频率。跟踪重新启动时重置。 + 诊断捕获 + 在本地保存一对立体图像。仅在请求时才保存图像。 + 保存相机图像 + 重新开始追踪 + 如果跟踪在光线充足的区域中无法恢复,请使用。重新启动需要新的跟踪源。 + 重启 + 重新开始追踪? + 未保存的校准视图将会丢失。之后请保持智能眼镜静止,并在追踪恢复后重置追踪中心。 + %1$d / 已捕获 24 次观看 + 捕获已暂停:%1$s + 测量%1$s。在两个预览中显示完整的校准目标,然后保持不动。 + %1$.1f Hz • 图像年龄 %2$.1f ms • 处理 %3$.1f ms + 输入限制%1$.1f Hz • 摄像机图像的%2$.0f%%。头部跟踪继续以其最大频率进行。 + %1$d 已处理 • %2$d 已丢弃 • %3$d 因输入限制而被跳过 + DroidDeck - Luma Ultra 校准 + 以 100%/实际尺寸打印。每个正方形:30 毫米(1.181 英寸)。 + 保持校准目标平坦且静止;在拍摄之间移动智能眼镜。 + 刻度检查:刻度之间 100 毫米(3.937 英寸) + 12 英寸(30.48 厘米) + 30 厘米(11.81 英寸) + 20 英寸(50.8 厘米) + 50 厘米(19.69 英寸) + 已停用 + 等待稳定跟踪 + 已断开连接 + 徒手操作的控制器已关闭 + 位置跟踪已关闭或智能眼镜已断开连接 + 已请求重置追踪中心 — 请在追踪稳定期间保持静止。 + 跟踪丢失 — 面对光线充足且细节可见的区域 + 追踪原点已更改 — 点击“重置追踪中心”,然后保持静止。 + 6DoF 主动 + 连接 Luma Ultra 并启用位置跟踪。 + 已验证此连接的校准。 + 校准已验证并保存。 + 等待立体摄像头 + 等待手部追踪 + 保持 5 × 7 校准目标静止。移动和旋转智能眼镜时捕获 24 个以上视图。 + 等待下一个摄像机图像。保持智能眼镜不动。 + 检查下一个摄像机图像。保持完整校准目标可见并保持静止。 + 首先开始校准 + 没有新的相机图像到达。检查智能眼镜连接和相机预览,然后重试。 + 相机时钟重置 + 追踪坐标系已更改。您的视图已保存以供重新计算。重置追踪中心,然后开始新的设置以捕获更多视图。 + 设备校准已加载 + Luma Ultra 基本校准已加载 + 需要校准 + 点击首先开始新的校准。 + 重置追踪中心正在等待稳定的追踪。请保持静止片刻。 + 追踪已更改。点击“重置追踪中心”一次,然后在捕获之前保持静止。 + 采集被拒绝:头部跟踪未同步,或在采集过程中发生了变化。保持不动后重试。 + 在检查距离之前计算相机对准。 + 相机处理失败 + 检测手部期间头部追踪发生变化 + 等待相机和云台同步 + 未检测到手腕。将 Joy-Con 控制器手柄放在智能眼镜前面 + 未检测到手。在智能眼镜前展示张开的手掌 + 仅在一台摄像机中可以看到手腕;将控制器句柄保留在共享视图中 + 仅在一台摄像机中可以看到手;将双手掌保持在共享视图中 + 两个摄像头都能看到手,但左/右匹配不明确 + 检测到手,但立体深度不一致 + 立体或运动检查拒绝手腕位置 + 检测到立体点,但手掌几何形状不一致 + 完成校准和距离检查以启用指针 + 正在等待稳定的头部追踪;如果需要,请重置追踪中心。 + 相机观察太旧;等待一双新的 + 适合 %1$.2f 像素。测量您选择的从左摄像头到校准目标中心的距离,然后进行验证。 + OpenCV 不可用:%1$s + %1$d 已恢复保存的视图。计算校准以重试,或开始新的一组以捕获更多。 + 已捕获 %1$d / 24 次观看。保持校准目标固定;移动智能眼镜以查看下一个视图。 + 捕获被拒绝:%1$d / 12 个必需的角在两个摄像头中均可见。显示更多校准目标,保持不动,然后重试。 + 距离检查无法完成:%1$s。再试一次。 + 检测到手不可用:%1$s。更换CPU/GPU或切换徒手操作的控制器重试。 + 检测手部超过%1$d毫秒;观察被丢弃 + %1$d / 2 个通过立体声测量的 Joy-Con 手腕位置 + 已追踪手掌:%1$d / 2;可用捏合手势:%2$d;可用抓取手势:%3$d + 已将诊断捕获保存到 %1$s + 手部追踪已停止:%1$s + 立体声%1$d×%2$d; %3$s + 头部跟踪和校准目标不一致 %1$s(限制 5 厘米/2 英寸)。保持校准目标固定并等待稳定跟踪,然后再开始新的一组。轻轻转动、倾斜智能眼镜;每次捕获之前暂停。 + 捕获固定校准目标的至少24个不同视图。 + 左右转动智能眼镜,上下倾斜;不旋转的移动无法校准相机对准。 + 难以置信的相机基线 + 通过更多不同的方向移动您的头部。 + 相机到头部旋转无效 + 相机与头部的对齐不一致。 + 校准无法完成。 %1$s 您捕获的视图已保存。 + 保留重投影错误 %1$.2f 像素超过 2 像素。重新校准。 + %1$d / 两个摄像头均检测到 24 个棋盘角。保持完整校准目标可见并保持静止。如果已经可见,请选择 12 英寸或 30 厘米,并在重试之前测量更近的距离。 + 校准目标是可见的,但无法可靠地测量其深度。保持智能眼镜不动,并保持校准目标平坦且光线充足,然后重试。 + 相机测量无效。保持不动,然后再试一次。 + 距离检查已通过。 + 重新检查左摄像机到校准目标中心的距离,然后重试。 + 测量相机%1$s;选择的距离%2$s。 %3$s + 开始校准之前等待两个摄像头预览。 + 可以重新计算保存的视图。开始新的校准以在当前跟踪坐标系中捕获。 + 手模型校验和不匹配 + OpenCV 无法加载 + 6DoF 虚拟屏幕 + 在光线充足的房间内缓慢环顾四周。\n不要遮挡追踪摄像头,并面向家具等有明显细节的物体。 + DroidDeck ChArUco 30 mm diff --git a/app/src/main/res/values-zh-rHK/strings.xml b/app/src/main/res/values-zh-rHK/strings.xml index 15a059f106..a8978f4543 100644 --- a/app/src/main/res/values-zh-rHK/strings.xml +++ b/app/src/main/res/values-zh-rHK/strings.xml @@ -2341,14 +2341,14 @@ 顯示 更新率 3D(左右並排) - 每隻眼睛各看 3840×1080 畫面的一半。如果畫面消失,請長按眼鏡上的 2D/3D 按鈕。 + 將智慧眼鏡切換至並排 3D 模式。頭部追蹤單獨控制。 未能確認 3D 訊號。請在 2D 畫面恢復後重試。 沒有畫面:眼鏡處於這部手機無法輸出的模式。請長按眼鏡的 2D/3D 按鈕,或拔除後重新連接。 3D 更新率 VR 遊戲使用 3D SteamVR 運行時切換到 3D,結束後切回。 - 3D 畫面 - 自動:SteamVR 填滿視野;其他遊戲在 3D 下以螢幕形式懸浮,在 2D 下保持平面。 + 圖片 + 自動模式會在雙眼顯示平面內容並偵測 SteamVR。選擇「並排遊戲」模式可顯示 SBS 內容。 自動 虛擬螢幕 左右並排遊戲 @@ -2358,20 +2358,20 @@ 這些設定在開啟「在眼鏡上顯示遊戲」且遊戲顯示於眼鏡上時生效。 「自動」會令這款 2D 遊戲全螢幕顯示。使用虛擬螢幕可調整其寬度、距離和頭部追蹤。 使用虛擬螢幕 - SteamVR 會填滿視野。可在下方調整其視場角;寬度和距離只適用於虛擬螢幕。 + SteamVR 將充滿整個視野。在 VR 中調整其視野範圍;寬度和距離僅適用於虛擬螢幕。 左右並排遊戲會填滿每隻眼睛的視野。寬度和距離只適用於虛擬螢幕。 「自動」會令這款 2D 遊戲固定在視野中。如要使用頭部追蹤,請在「顯示」中選擇「虛擬螢幕」。 頭部追蹤適用於虛擬螢幕或正在運行的 SteamVR 遊戲。 - 眼鏡 + 設備 亮度 音量 遮光 令前鏡片變暗。 - 頭部追蹤 + 追蹤 頭部追蹤 眼鏡自帶的感應器會隨頭部轉動虛擬螢幕和 SteamVR。 重新置中視角 - 重新置中 + 重設螢幕中心 SteamVR 視場角 調低令 SteamVR 更近並填滿眼鏡;調高可看到更多周圍內容。 正在 %1$s 上遊玩 @@ -2392,8 +2392,8 @@ 要移除已儲存的校準並還原此型號的預設值嗎?重新戴上眼鏡後請重新置中。 重設 手部追蹤 - 要用相機追蹤你的雙手嗎? - 相機能看到你的雙手。未連接控制器時,你的雙手會直接成為 VR 中的手:拇指和食指捏合即可點擊,握拳即可抓取,掌心朝向自己再捏合即可打開選單。使用 Joy-Con 時,會把它們放在你雙手的實際位置。畫面會在此裝置上處理,絕不會被儲存或傳送。 + 使用手機相機追蹤手部或 Joy-Con 控制器? + 未連接控制器時,手機相機會在 VR 中追蹤您的裸手:拇指和食指捏合即可點擊,握緊拳頭即可抓取,掌心朝向自己並捏合即可打開選單。連接 Joy-Con 控制器後,相機會追蹤其位置,同時 Joy-Con 控制器會提供旋轉和按鍵輸入。照片會在本設備上處理,不會儲存或傳送。 後置相機 建議使用。通常更清晰、視野更廣。 前置相機 @@ -2401,7 +2401,7 @@ 使用相機 稍後 相機手部追蹤 - 未連接控制器時,你的雙手會成為 VR 中的手:捏合即可點擊,掌心朝向自己再捏合即可打開選單。使用 Joy-Con 時,會將其放在相機看到的位置。畫面不會離開此裝置。 + 使用手機相機進行徒手手勢操作或在 VR 中定位已配對的 Joy-Con 控制器。 Joy-Con 控制器提供旋轉和按鍵輸入。當智慧眼鏡追蹤您的手或 Joy-Con 控制器時,此功能會暫停。影像僅在此裝置上處理。 相機 相機權限 請允許相機權限,才能開始手部追蹤。 @@ -2655,4 +2655,208 @@ 正在為 Steam 轉換 %1$s。請保持 DroidDeck 開啟。 此裝置無法解碼該影片。 無法匯入此影片 + Luma Ultra 相機 — 實驗性功能 + Joy-Con 位置追踪 + 使用智慧眼鏡攝影機定位已配對的 Joy-Con 控制器。旋轉和按鍵輸入來自 Joy-Con 控制器。當您的手腕被遮住時,系統會估算位置。此功能會取代徒手操作的控制器,並暫停手機相機追蹤。連接或重設追蹤中心時,請將 Joy-Con 控制器指向前方。 + 請先啟用位置追蹤功能。需要 Android 12 或更高版本且 Joy-Con 控制器支援體感功能。預設關閉。 + 智慧眼鏡 + 顯示和頭部追蹤設定可在 DroidDeck 選單、遊戲和桌面會話之間共用。 + 連接智慧眼鏡以變更其顯示和追蹤設定。斷開連線後,您儲存的設定將被保留。 + VR + 顯示模式 + 2D 輸出 + 3D 輸出 + 畫面與虛擬螢幕 + 位置與地面高度 + 手部追蹤 — 實驗性功能 + 追蹤狀態 + 2D 分辨率 + 3D 分辨率 + VR 分辨率 + 自動 + 與 2D / 3D 相同 + 單眼輸出分辨率 + 啟用智慧眼鏡遊戲功能,選擇顯示器的原生 30 Hz 模式。 + 3DoF 虛擬螢幕 + 將平面遊戲固定在您面前,以便您可以環顧四周。無需切換到 3D 模式即可啟用智慧眼鏡遊戲功能。 + 寬度和距離會立即更新 DroidDeck 選單、遊戲和桌面會話的追蹤虛擬畫面。 + 位置追蹤包含 SteamVR 中的頭部旋轉。如需僅進行旋轉追踪,請關閉位置追蹤。 + 控制虛擬螢幕上的頭部移動。位置追蹤包含 SteamVR 中的頭部旋轉。 + 快速操作 + 看向您希望螢幕顯示的位置,然後重設追蹤中心以設定其高度和方向。 + 重設 Joy-Con 中心 + 手機相機 — 實驗性功能 + 追蹤手部或 Joy-Con 控制器 + 位置追蹤 — 實驗性功能 + 在VR中以及虛擬螢幕周圍進行實體移動。重新開始追蹤需要一些時間。 + 當前眼睛離地面的高度 + 依照目前高度設定地面高度 + 設定地面高度 + 立體攝影機設定與診斷 + 遊戲前檢查相機校準和手部追蹤。 + 開啟設定 + 用手操作控制器 + 使用智慧眼鏡攝影機用手瞄準,捏合點擊,握緊手掌抓取VR中的物品。遊戲手把搖桿可以移動和旋轉。取代Joy-Con的位置追蹤。遊戲過程中可能會出現延遲或追蹤遺失。 + 在追蹤設定中,啟用Luma Ultra攝影機下的徒手操作控制器。首先顯示張開的手。 + 共享Luma Ultra校準 + 使用共用的Luma Ultra底座。校準您的智慧眼鏡以驗證其準確性。 + 測量校準已驗證 + 需要驗證 + 測量距離檢查後,即可使用裸手操作控制器。 + 追蹤遺失 + 還卡住了嗎?在手機上:智慧型眼鏡→追蹤→開啟設定→顯示診斷→重新啟動追蹤。 + 智慧眼鏡斷開連接 + 檢查 USB 連接並重新連接智慧眼鏡。\n如果手機上出現 USB 存取提示,請接受該提示。 + 連結後,在光線充足的房間中慢慢環顧四周以恢復跟踪。 + 需要重設中心 + 追蹤已恢復到新位置。\n看向前方,然後在手機上點選「重置追蹤中心」。 + 您也可以在智慧眼鏡 → 追蹤 → 開啟設定中找到重置追蹤中心。您儲存的相機校準資訊將會保留。 + 等一下 + 重置追蹤中心正在進行中。\n請在追蹤穩定期間保持智慧眼鏡靜止。 + 當頭部追蹤準備就緒時,此畫面自動關閉。 + 穩定雙手瞄準 + 從肩膀到手掌瞄準。關閉以進行手腕控制旋轉。 + 空間設定 + 等待追蹤… + 左、右跟蹤攝影機 + 相機同步 + 準備好了 + 等待相機和頭部追蹤對齊。保持智慧眼鏡連接。 + 1.準備校準目標 + 以實際尺寸列印 + 每個正方形的尺寸必須為 30 毫米(1.181 吋)。將板材平坦地安裝在光線充足區域的剛性表面上。 + 列印校準板 + 2.捕捉不同的觀點 + 保持校準目標靜止 + 將智慧眼鏡移近、移遠和側向移動。向左/向右轉動它們,向上/向下傾斜它們,並向側面傾斜它們。將校準目標保留在兩台相機中,並在每次捕獲之前短暫暫停。 + 開始新的校準 + 等待相機同步。 + 開始新的校準以收集視圖。 + 保持校準目標在兩個預覽中可見。從不同角度捕捉至少 24 個清晰視野。 + 捕捉… + 捕捉校準目標視圖 + 計算相機對準 + 正在計算中… + 計算校準 + 3.檢查距離 + 測量距離 + 從 12 英吋或 30 公分開始,以便列印的標記更容易檢測到。選擇您將使用的精確測量值。 + 左相機至標定目標中心 + 檢查距離… + 驗證距離 + 診斷 + 顯示診斷 + 相機定時與追蹤恢復工具。 + 相機計時 + 來自手部追蹤的輸入 + 等待相機計時。 + 相機影像 + GPU檢測手部 + CPU 是預設值。 GPU 是實驗性的,可能會導致 SteamVR 重新啟動。當追蹤重新啟動時,此選擇會重置。 + 手部模型的精簡檢測 + 使用 Lite 手掌偵測器和手上的 Lite 重點。檢查瞄準、捏合和抓取的準確性。追蹤重新啟動時重置。 + 自動輸入頻率以追蹤手部 + 調整輸入處理速度。追蹤重新啟動時重置。 + 限製手部追蹤的輸入頻率 + 使用一半的相機影像。關閉以比較最大頻率。追蹤重新啟動時重置。 + 診斷捕獲 + 在本地保存一對立體影像。僅在請求時才儲存影像。 + 儲存相機影像 + 重新開始追蹤 + 如果追蹤在光線充足的區域中無法恢復,請使用。重新啟動需要新的追蹤來源。 + 重啟 + 重新開始追蹤? + 未儲存的校準視圖將會遺失。之後請保持智慧眼鏡靜止,並在追蹤恢復後重置追蹤中心。 + %1$d / 已捕獲 24 次觀看 + 擷取已暫停:%1$s + 測量%1$s。在兩個預覽中顯示完整的校準目標,然後保持不動。 + %1$.1f Hz • 影像年齡 %2$.1f ms • 處理 %3$.1f ms + 輸入限制%1$.1f Hz • 攝影機影像的%2$.0f%%。頭部追蹤繼續以其最大頻率進行。 + %1$d 已處理 • %2$d 已丟棄 • %3$d 因輸入限製而被跳過 + DroidDeck - Luma Ultra 校準 + 以 100%/實際尺寸列印。每個正方形:30 毫米(1.181 吋)。 + 保持校準目標平坦且靜止;在拍攝之間移動智慧眼鏡。 + 刻度檢查:刻度之間 100 毫米(3.937 吋) + 12 吋(30.48 公分) + 30 公分(11.81 吋) + 20 吋(50.8 公分) + 50 公分(19.69 吋) + 已停用 + 等待穩定跟踪 + 已斷開連接 + 徒手操作的控制器已關閉 + 位置追蹤已關閉或智慧眼鏡已斷開連接 + 已要求重置追蹤中心 — 請在追蹤穩定期間保持靜止。 + 追蹤失去 — 面對光線充足且細節可見的區域 + 追蹤原點已更改 — 點擊“重置追蹤中心”,然後保持靜止。 + 6DoF 主動 + 連接 Luma Ultra 並啟用位置追蹤。 + 已驗證此連接的校準。 + 校準已驗證並儲存。 + 等待立體攝影機 + 等待手部追蹤 + 保持 5 × 7 校準目標靜止。移動和旋轉智慧眼鏡時可捕捉 24 個以上視圖。 + 等待下一個攝影機影像。保持智慧眼鏡不動。 + 檢查下一個攝影機影像。保持完整校準目標可見並保持靜止。 + 先開始校準 + 沒有新的相機影像到達。檢查智慧眼鏡連接和相機預覽,然後重試。 + 相機時鐘重置 + 追蹤座標系已更改。您的視圖已儲存以供重新計算。重置追蹤中心,然後開始新的設定以捕獲更多視圖。 + 設備校準已載入 + Luma Ultra 基本校準已載入 + 需要校準 + 點選先開始新的校準。 + 重置追蹤中心正在等待穩定的追蹤。請保持靜止片刻。 + 追蹤已更改。點擊“重置追蹤中心”一次,然後在捕獲之前保持靜止。 + 擷取被拒絕:頭部追蹤未同步,或在擷取過程中發生了變化。保持不動後重試。 + 在檢查距離之前計算相機對準。 + 相機處理失敗 + 偵測手部期間頭部追蹤發生變化 + 等待相機和雲台同步 + 未偵測到手腕。將 Joy-Con 控制器手把放在智慧眼鏡前面 + 未偵測到手。在智慧眼鏡前展示張開的手掌 + 僅在一台攝影機中可以看到手腕;將控制器句柄保留在共享視圖中 + 僅在一台攝影機中可以看到手;將雙手掌保持在共享視圖中 + 兩個攝影機都能看到手,但左/右匹配不明確 + 偵測到手,但立體深度不一致 + 立體或運動檢查拒絕手腕位置 + 偵測到立體點,但手掌幾何形狀不一致 + 完成校準和距離檢查以啟用指針 + 正在等待穩定的頭部追蹤;如果需要,請重設追蹤中心。 + 相機觀察太舊;等待一雙新的 + 適合 %1$.2f 像素。測量您選擇的從左側攝影機到校準目標中心的距離,然後進行驗證。 + OpenCV 不可用:%1$s + %1$d 已恢復已儲存的視圖。計算校準以重試,或開始新的一組以捕獲更多。 + 已捕獲 %1$d / 24 次觀看。保持校準目標固定;移動智慧眼鏡以查看下一個視圖。 + 捕捉被拒絕:%1$d / 12 個必需的角落在兩個攝影機中均可見。顯示更多校準目標,保持不動,然後重試。 + 距離檢查無法完成:%1$s。再試一次。 + 偵測到手部不可用:%1$s。更換CPU/GPU或切換徒手操作的控制器重試。 + 偵測手部超過%1$d毫秒;觀察被丟棄 + %1$d / 2 以立體聲測量的 Joy-Con 手腕位置 + 已追蹤手掌:%1$d / 2;可用捏合手勢:%2$d;可用抓取手勢:%3$d + 已將診斷擷取儲存到 %1$s + 手部追蹤已停止:%1$s + 立體聲%1$d×%2$d;%3$s + 頭部追蹤和校準目標不一致 %1$s(限制 5 公分/2 英吋)。保持校準目標固定並等待穩定跟踪,然後再開始新的一組。輕輕轉動、傾斜智慧眼鏡;每次捕獲前暫停。 + 捕捉固定校準目標的至少24個不同視圖。 + 左右轉動智慧眼鏡,上下傾斜;不旋轉的移動無法校準相機對準。 + 難以置信的相機基線 + 透過更多不同的方向移動您的頭部。 + 相機到頭旋轉無效 + 相機與頭部的對齊不一致。 + 校準無法完成。 %1$s 您所擷取的視圖已儲存。 + 保留重投影錯誤 %1$.2f 像素超過 2 像素。重新校準。 + %1$d / 兩個相機都偵測到 24 個棋盤角。保持完整校準目標可見並保持靜止。如果已經可見,請選擇 12 英寸或 30 厘米,並在重試之前測量更近的距離。 + 校準目標是可見的,但無法可靠地測量其深度。保持智慧眼鏡不動,並保持校準目標平坦且光線充足,然後重試。 + 相機測量無效。保持不動,然後再試一次。 + 距離檢查已通過。 + 重新檢查左攝影機到校準目標中心的距離,然後重試。 + 測量相機%1$s;所選的距離%2$s。 %3$s + 開始校準之前等待兩個攝影機預覽。 + 可以重新計算已儲存的視圖。開始新的校準以在當前追蹤座標系中捕獲。 + 手模型校驗與不匹配 + OpenCV 無法載入 + 6DoF 虛擬螢幕 + 在光線充足的房間內緩慢環顧四周。\n不要遮擋追蹤攝影機,並面向家具等有明顯細節的物體。 + DroidDeck ChArUco 30 mm diff --git a/app/src/main/res/values-zh-rTW/strings.xml b/app/src/main/res/values-zh-rTW/strings.xml index b66b3948a9..84195dcd7c 100644 --- a/app/src/main/res/values-zh-rTW/strings.xml +++ b/app/src/main/res/values-zh-rTW/strings.xml @@ -2341,14 +2341,14 @@ 顯示 更新率 3D(左右並排) - 每隻眼睛各看 3840×1080 畫面的一半。如果畫面消失,請長按眼鏡上的 2D/3D 按鈕。 + 將智慧眼鏡切換至並排 3D 模式。頭部追蹤單獨控制。 未能確認 3D 訊號。請在 2D 畫面恢復後再試。 沒有畫面:眼鏡處於這支手機無法輸出的模式。請長按眼鏡的 2D/3D 按鈕,或拔除後重新連接。 3D 更新率 VR 遊戲使用 3D SteamVR 執行時切換到 3D,結束後切回。 - 3D 畫面 - 自動:SteamVR 填滿視野;其他遊戲在 3D 下以螢幕形式懸浮,在 2D 下保持平面。 + 圖片 + 自動模式會在雙眼顯示平面內容並偵測 SteamVR。選擇「並排遊戲」模式可顯示 SBS 內容。 自動 虛擬螢幕 左右並排遊戲 @@ -2358,20 +2358,20 @@ 這些設定會在開啟「在眼鏡上顯示遊戲」且遊戲顯示於眼鏡上時生效。 「自動」會讓這款 2D 遊戲全螢幕顯示。使用虛擬螢幕即可調整其寬度、距離和頭部追蹤。 使用虛擬螢幕 - SteamVR 會填滿視野。可在下方調整其視野角度;寬度和距離只適用於虛擬螢幕。 + SteamVR 將充滿整個視野。在 VR 中調整其視野範圍;寬度和距離僅適用於虛擬螢幕。 左右並排遊戲會填滿每隻眼睛的視野。寬度和距離只適用於虛擬螢幕。 「自動」會讓這款 2D 遊戲固定在視野中。如要使用頭部追蹤,請在「顯示」中選擇「虛擬螢幕」。 頭部追蹤適用於虛擬螢幕或執行中的 SteamVR 遊戲。 - 眼鏡 + 設備 亮度 音量 遮光 讓前鏡片變暗。 - 頭部追蹤 + 追蹤 頭部追蹤 眼鏡內建的感測器會隨頭部轉動虛擬螢幕和 SteamVR。 重新置中視角 - 重新置中 + 重設螢幕中心 SteamVR 視野角度 調低讓 SteamVR 更近並填滿眼鏡;調高可看到更多周圍內容。 正在 %1$s 上遊玩 @@ -2392,8 +2392,8 @@ 要移除已儲存的校正並還原此型號的預設值嗎?重新戴上眼鏡後請重新置中。 重設 手部追蹤 - 要用相機追蹤你的雙手嗎? - 相機能看到你的雙手。未連接控制器時,你的雙手會直接成為 VR 中的手:拇指和食指捏合即可點選,握拳即可抓取,掌心朝向自己再捏合即可開啟選單。使用 Joy-Con 時,會把它們放在你雙手的實際位置。畫面會在此裝置上處理,絕不會被儲存或傳送。 + 使用手機相機追蹤手部或 Joy-Con 控制器? + 未連接控制器時,手機相機會在 VR 中追蹤您的裸手:拇指和食指捏合即可點擊,握緊拳頭即可抓取,掌心朝向自己並捏合即可打開選單。連接 Joy-Con 控制器後,相機會追蹤其位置,同時 Joy-Con 控制器會提供旋轉和按鍵輸入。照片會在本設備上處理,不會儲存或傳送。 後置相機 建議使用。通常更清晰、視野更廣。 前置相機 @@ -2401,7 +2401,7 @@ 使用相機 暫時不要 相機手部追蹤 - 未連接控制器時,你的雙手會成為 VR 中的手:捏合即可點選,掌心朝向自己再捏合即可開啟選單。使用 Joy-Con 時,會將其放在相機看到的位置。畫面不會離開此裝置。 + 使用手機相機進行徒手手勢操作或在 VR 中定位已配對的 Joy-Con 控制器。 Joy-Con 控制器提供旋轉和按鍵輸入。當智慧眼鏡追蹤您的手或 Joy-Con 控制器時,此功能會暫停。影像僅在此裝置上處理。 相機 相機權限 請允許相機權限,才能開始手部追蹤。 @@ -2655,4 +2655,208 @@ 正在為 Steam 轉換 %1$s。請保持 DroidDeck 開啟。 此裝置無法解碼該影片。 無法匯入此影片 + Luma Ultra 相機 — 實驗性功能 + Joy-Con 位置追踪 + 使用智慧眼鏡攝影機定位已配對的 Joy-Con 控制器。旋轉和按鍵輸入來自 Joy-Con 控制器。當您的手腕被遮住時,系統會估算位置。此功能會取代徒手操作的控制器,並暫停手機相機追蹤。連接或重設追蹤中心時,請將 Joy-Con 控制器指向前方。 + 請先啟用位置追蹤功能。需要 Android 12 或更高版本且 Joy-Con 控制器支援體感功能。預設關閉。 + 智慧眼鏡 + 顯示和頭部追蹤設定可在 DroidDeck 選單、遊戲和桌面會話之間共用。 + 連接智慧眼鏡以變更其顯示和追蹤設定。斷開連線後,您儲存的設定將被保留。 + VR + 顯示模式 + 2D 輸出 + 3D 輸出 + 畫面與虛擬螢幕 + 位置與地面高度 + 手部追蹤 — 實驗性功能 + 追蹤狀態 + 2D 分辨率 + 3D 分辨率 + VR 分辨率 + 自動 + 與 2D / 3D 相同 + 單眼輸出分辨率 + 啟用智慧眼鏡遊戲功能,選擇顯示器的原生 30 Hz 模式。 + 3DoF 虛擬螢幕 + 將平面遊戲固定在您面前,以便您可以環顧四周。無需切換到 3D 模式即可啟用智慧眼鏡遊戲功能。 + 寬度和距離會立即更新 DroidDeck 選單、遊戲和桌面會話的追蹤虛擬畫面。 + 位置追蹤包含 SteamVR 中的頭部旋轉。如需僅進行旋轉追踪,請關閉位置追蹤。 + 控制虛擬螢幕上的頭部移動。位置追蹤包含 SteamVR 中的頭部旋轉。 + 快速操作 + 看向您希望螢幕顯示的位置,然後重設追蹤中心以設定其高度和方向。 + 重設 Joy-Con 中心 + 手機相機 — 實驗性功能 + 追蹤手部或 Joy-Con 控制器 + 位置追蹤 — 實驗性功能 + 在VR中以及虛擬螢幕周圍進行實體移動。重新開始追蹤需要一些時間。 + 當前眼睛離地面的高度 + 依照目前高度設定地面高度 + 設定地面高度 + 立體攝影機設定與診斷 + 遊戲前檢查相機校準和手部追蹤。 + 開啟設定 + 用手操作控制器 + 使用智慧眼鏡攝影機用手瞄準,捏合點擊,握緊手掌抓取VR中的物品。遊戲手把搖桿可以移動和旋轉。取代Joy-Con的位置追蹤。遊戲過程中可能會出現延遲或追蹤遺失。 + 在追蹤設定中,啟用Luma Ultra攝影機下的徒手操作控制器。首先顯示張開的手。 + 共享Luma Ultra校準 + 使用共用的Luma Ultra底座。校準您的智慧眼鏡以驗證其準確性。 + 測量校準已驗證 + 需要驗證 + 測量距離檢查後,即可使用裸手操作控制器。 + 追蹤遺失 + 還卡住了嗎?在手機上:智慧型眼鏡→追蹤→開啟設定→顯示診斷→重新啟動追蹤。 + 智慧眼鏡斷開連接 + 檢查 USB 連接並重新連接智慧眼鏡。\n如果手機上出現 USB 存取提示,請接受該提示。 + 連結後,在光線充足的房間中慢慢環顧四周以恢復跟踪。 + 需要重設中心 + 追蹤已恢復到新位置。\n看向前方,然後在手機上點選「重置追蹤中心」。 + 您也可以在智慧眼鏡 → 追蹤 → 開啟設定中找到重置追蹤中心。您儲存的相機校準資訊將會保留。 + 等一下 + 重置追蹤中心正在進行中。\n請在追蹤穩定期間保持智慧眼鏡靜止。 + 當頭部追蹤準備就緒時,此畫面自動關閉。 + 穩定雙手瞄準 + 從肩膀到手掌瞄準。關閉以進行手腕控制旋轉。 + 空間設定 + 等待追蹤… + 左、右跟蹤攝影機 + 相機同步 + 準備好了 + 等待相機和頭部追蹤對齊。保持智慧眼鏡連接。 + 1.準備校準目標 + 以實際尺寸列印 + 每個正方形的尺寸必須為 30 毫米(1.181 吋)。將板材平坦地安裝在光線充足區域的剛性表面上。 + 列印校準板 + 2.捕捉不同的觀點 + 保持校準目標靜止 + 將智慧眼鏡移近、移遠和側向移動。向左/向右轉動它們,向上/向下傾斜它們,並向側面傾斜它們。將校準目標保留在兩台相機中,並在每次捕獲之前短暫暫停。 + 開始新的校準 + 等待相機同步。 + 開始新的校準以收集視圖。 + 保持校準目標在兩個預覽中可見。從不同角度捕捉至少 24 個清晰視野。 + 捕捉… + 捕捉校準目標視圖 + 計算相機對準 + 正在計算中… + 計算校準 + 3.檢查距離 + 測量距離 + 從 12 英吋或 30 公分開始,以便列印的標記更容易檢測到。選擇您將使用的精確測量值。 + 左相機至標定目標中心 + 檢查距離… + 驗證距離 + 診斷 + 顯示診斷 + 相機定時與追蹤恢復工具。 + 相機計時 + 來自手部追蹤的輸入 + 等待相機計時。 + 相機影像 + GPU檢測手部 + CPU 是預設值。 GPU 是實驗性的,可能會導致 SteamVR 重新啟動。當追蹤重新啟動時,此選擇會重置。 + 手部模型的精簡檢測 + 使用 Lite 手掌偵測器和手上的 Lite 重點。檢查瞄準、捏合和抓取的準確性。追蹤重新啟動時重置。 + 自動輸入頻率以追蹤手部 + 調整輸入處理速度。追蹤重新啟動時重置。 + 限製手部追蹤的輸入頻率 + 使用一半的相機影像。關閉以比較最大頻率。追蹤重新啟動時重置。 + 診斷捕獲 + 在本地保存一對立體影像。僅在請求時才儲存影像。 + 儲存相機影像 + 重新開始追蹤 + 如果追蹤在光線充足的區域中無法恢復,請使用。重新啟動需要新的追蹤來源。 + 重啟 + 重新開始追蹤? + 未儲存的校準視圖將會遺失。之後請保持智慧眼鏡靜止,並在追蹤恢復後重置追蹤中心。 + %1$d / 已捕獲 24 次觀看 + 擷取已暫停:%1$s + 測量%1$s。在兩個預覽中顯示完整的校準目標,然後保持不動。 + %1$.1f Hz • 影像年齡 %2$.1f ms • 處理 %3$.1f ms + 輸入限制%1$.1f Hz • 攝影機影像的%2$.0f%%。頭部追蹤繼續以其最大頻率進行。 + %1$d 已處理 • %2$d 已丟棄 • %3$d 因輸入限製而被跳過 + DroidDeck - Luma Ultra 校準 + 以 100%/實際尺寸列印。每個正方形:30 毫米(1.181 吋)。 + 保持校準目標平坦且靜止;在拍攝之間移動智慧眼鏡。 + 刻度檢查:刻度之間 100 毫米(3.937 吋) + 12 吋(30.48 公分) + 30 公分(11.81 吋) + 20 吋(50.8 公分) + 50 公分(19.69 吋) + 已停用 + 等待穩定跟踪 + 已斷開連接 + 徒手操作的控制器已關閉 + 位置追蹤已關閉或智慧眼鏡已斷開連接 + 已要求重置追蹤中心 — 請在追蹤穩定期間保持靜止。 + 追蹤失去 — 面對光線充足且細節可見的區域 + 追蹤原點已更改 — 點擊“重置追蹤中心”,然後保持靜止。 + 6DoF 主動 + 連接 Luma Ultra 並啟用位置追蹤。 + 已驗證此連接的校準。 + 校準已驗證並儲存。 + 等待立體攝影機 + 等待手部追蹤 + 保持 5 × 7 校準目標靜止。移動和旋轉智慧眼鏡時可捕捉 24 個以上視圖。 + 等待下一個攝影機影像。保持智慧眼鏡不動。 + 檢查下一個攝影機影像。保持完整校準目標可見並保持靜止。 + 先開始校準 + 沒有新的相機影像到達。檢查智慧眼鏡連接和相機預覽,然後重試。 + 相機時鐘重置 + 追蹤座標系已更改。您的視圖已儲存以供重新計算。重置追蹤中心,然後開始新的設定以捕獲更多視圖。 + 設備校準已載入 + Luma Ultra 基本校準已載入 + 需要校準 + 點選先開始新的校準。 + 重置追蹤中心正在等待穩定的追蹤。請保持靜止片刻。 + 追蹤已更改。點擊“重置追蹤中心”一次,然後在捕獲之前保持靜止。 + 擷取被拒絕:頭部追蹤未同步,或在擷取過程中發生了變化。保持不動後重試。 + 在檢查距離之前計算相機對準。 + 相機處理失敗 + 偵測手部期間頭部追蹤發生變化 + 等待相機和雲台同步 + 未偵測到手腕。將 Joy-Con 控制器手把放在智慧眼鏡前面 + 未偵測到手。在智慧眼鏡前展示張開的手掌 + 僅在一台攝影機中可以看到手腕;將控制器句柄保留在共享視圖中 + 僅在一台攝影機中可以看到手;將雙手掌保持在共享視圖中 + 兩個攝影機都能看到手,但左/右匹配不明確 + 偵測到手,但立體深度不一致 + 立體或運動檢查拒絕手腕位置 + 偵測到立體點,但手掌幾何形狀不一致 + 完成校準和距離檢查以啟用指針 + 正在等待穩定的頭部追蹤;如果需要,請重設追蹤中心。 + 相機觀察太舊;等待一雙新的 + 適合 %1$.2f 像素。測量您選擇的從左側攝影機到校準目標中心的距離,然後進行驗證。 + OpenCV 不可用:%1$s + %1$d 已恢復已儲存的視圖。計算校準以重試,或開始新的一組以捕獲更多。 + 已捕獲 %1$d / 24 次觀看。保持校準目標固定;移動智慧眼鏡以查看下一個視圖。 + 捕捉被拒絕:%1$d / 12 個必需的角落在兩個攝影機中均可見。顯示更多校準目標,保持不動,然後重試。 + 距離檢查無法完成:%1$s。再試一次。 + 偵測到手部不可用:%1$s。更換CPU/GPU或切換徒手操作的控制器重試。 + 偵測手部超過%1$d毫秒;觀察被丟棄 + %1$d / 2 以立體聲測量的 Joy-Con 手腕位置 + 已追蹤手掌:%1$d / 2;可用捏合手勢:%2$d;可用抓取手勢:%3$d + 已將診斷擷取儲存到 %1$s + 手部追蹤已停止:%1$s + 立體聲%1$d×%2$d;%3$s + 頭部追蹤和校準目標不一致 %1$s(限制 5 公分/2 英吋)。保持校準目標固定並等待穩定跟踪,然後再開始新的一組。輕輕轉動、傾斜智慧眼鏡;每次捕獲前暫停。 + 捕捉固定校準目標的至少24個不同視圖。 + 左右轉動智慧眼鏡,上下傾斜;不旋轉的移動無法校準相機對準。 + 難以置信的相機基線 + 透過更多不同的方向移動您的頭部。 + 相機到頭旋轉無效 + 相機與頭部的對齊不一致。 + 校準無法完成。 %1$s 您所擷取的視圖已儲存。 + 保留重投影錯誤 %1$.2f 像素超過 2 像素。重新校準。 + %1$d / 兩個相機都偵測到 24 個棋盤角。保持完整校準目標可見並保持靜止。如果已經可見,請選擇 12 英寸或 30 厘米,並在重試之前測量更近的距離。 + 校準目標是可見的,但無法可靠地測量其深度。保持智慧眼鏡不動,並保持校準目標平坦且光線充足,然後重試。 + 相機測量無效。保持不動,然後再試一次。 + 距離檢查已通過。 + 重新檢查左攝影機到校準目標中心的距離,然後重試。 + 測量相機%1$s;所選的距離%2$s。 %3$s + 開始校準之前等待兩個攝影機預覽。 + 可以重新計算已儲存的視圖。開始新的校準以在當前追蹤座標系中捕獲。 + 手模型校驗與不匹配 + OpenCV 無法載入 + 6DoF 虛擬螢幕 + 在光線充足的房間內緩慢環顧四周。\n不要遮擋追蹤攝影機,並面向家具等有明顯細節的物體。 + DroidDeck ChArUco 30 mm diff --git a/app/src/main/res/values/strings.xml b/app/src/main/res/values/strings.xml index 8156f5c4ea..dfe9325731 100644 --- a/app/src/main/res/values/strings.xml +++ b/app/src/main/res/values/strings.xml @@ -1,5 +1,9 @@ + Luma Ultra cameras — Experimental + Joy-Con position tracking + Use the glasses cameras to position your paired Joy-Cons. Rotation and button inputs come from the Joy-Cons. Position is estimated when your wrists are hidden. Replaces bare-hand controllers and pauses phone-camera tracking. Point the Joy-Cons forward when connecting or recentering. + Enable positional tracking first. Requires motion-capable Joy-Cons on Android 12 or later. Off by default. SteamVR graphics stopped DroidDeck will restart in %1$d seconds to reset graphics and reopen SteamVR. Your running game will close; unsaved progress cannot be restored. The graphics fault returned after a recent restart. Automatic recovery is paused to prevent a loop. Restarting will close your game; unsaved progress cannot be restored. @@ -2285,6 +2289,9 @@ This device Remove %1$s? Diagnostics + Smart glasses + Display and head-tracking settings are shared across DroidDeck menus, games and desktop sessions. + Connect smart glasses to change their display and tracking settings. Your saved settings are kept when you disconnect. Ready to play Not ready to play yet runtime %1$s @@ -2418,39 +2425,62 @@ Game on glasses Show the game only on the glasses. Off: the phone shows it and Android mirrors the phone. Display + VR + Display mode + 2D output + 3D output + Picture and virtual screen + Position and floor + Hand tracking — Experimental + Tracking status + 2D resolution + 3D resolution + VR resolution + Automatic + Same as 2D / 3D + Output resolution per eye. Refresh rate + Enable Game on glasses to select the display’s native 30 Hz mode. 3D (side-by-side) - Each eye gets its own half of a 3840×1080 picture. If the picture drops out, hold the glasses\' 2D/3D button. + Switch the glasses to side-by-side 3D. Head tracking is controlled separately. + 3DoF virtual screen + Anchor flat games in front of you so you can look around. Enables Game on glasses without switching to 3D. The 3D signal was not confirmed. Try again once the 2D picture returns. No picture: the glasses are in a mode this phone can\'t send. Hold their 2D/3D button, or unplug and replug them. 3D refresh rate 3D for VR games Switches to 3D while SteamVR runs, and back after. - 3D picture - Automatic: SteamVR fills the view; other games hang as a screen in 3D and stay flat in 2D. + Picture + Automatic shows flat content in both eyes and detects SteamVR. Choose Side-by-side game for SBS content. Automatic Virtual screen Side-by-side game Screen width Screen distance Width and distance apply when a game runs on the glasses as a virtual screen. + Width and distance update the tracked virtual screen for DroidDeck menus, games and desktop sessions immediately. These settings apply while Game on glasses is enabled and the game is displayed there. Automatic keeps this 2D game full-screen. Use a virtual screen to adjust its width, distance and head tracking. Use virtual screen - SteamVR fills the view. Adjust its field of view below; width and distance apply only to a virtual screen. + SteamVR fills the view. Adjust its field of view in VR; width and distance apply only to a virtual screen. Side-by-side games fill each eye. Width and distance apply only to a virtual screen. Automatic keeps this 2D game fixed in view. Choose Virtual screen in Display to use head tracking. Head tracking applies to a virtual screen or a running SteamVR game. - Glasses + Device Brightness Volume Sunblock Darkens the front lenses. - Head tracking + Tracking Head tracking The glasses\' own sensors turn the virtual screen and SteamVR with your head. + Positional tracking includes head rotation in SteamVR. For rotation-only tracking, turn off positional tracking. + Controls head movement on the virtual screen. Positional tracking includes head rotation in SteamVR. + Quick actions Recenter view - Recenter + Look where you want the screen, then recenter to set its height and direction. + Recenter Screen + Recenter Joy-Cons SteamVR field of view Lower brings SteamVR closer and fills the glasses; higher shows more around you. Playing on %1$s @@ -2471,8 +2501,9 @@ Remove the saved calibration and restore the model defaults? Recenter after putting the glasses back on. Reset Hand tracking - Track your hands with the camera? - The camera can see your hands. With no controller connected, your bare hands become the VR hands: pinch your thumb and index finger to click, close your hand to grab, and turn your palm toward you and pinch to open the menu. With Joy-Cons, it puts them where your hands really are. Pictures are processed on this device and never saved or sent. + Phone camera — Experimental + Track hands or Joy-Cons with the phone camera? + With no controller connected, the phone camera tracks your bare hands in VR: pinch your thumb and index finger to click, close your hand to grab, and turn your palm toward you and pinch to open the menu. With paired Joy-Cons, the camera tracks their position while the Joy-Cons provide rotation and button inputs. Pictures are processed on this device and never saved or sent. Back camera Recommended. Usually sharper and wider. Front camera @@ -2480,7 +2511,8 @@ Use camera Not now Camera hand tracking - With no controller connected, your hands become the VR hands: pinch to click, palm toward you and pinch for the menu. With Joy-Cons, it places them where the camera sees them. Pictures stay on this device. + Track hands or Joy-Cons + Use the phone camera for bare-hand gestures or to position paired Joy-Cons in VR. Joy-Cons provide rotation and button inputs. Pauses while the glasses track your hands or Joy-Cons. Pictures stay on this device. Camera Camera access Allow camera access so hand tracking can start. @@ -2512,6 +2544,15 @@ Top Bottom Center (default) + 6DoF virtual screen + Positional tracking — experimental + Physical movement in VR and around virtual screens. Restarting tracking takes a moment. + Current eye height above floor + Set floor from current height + Set floor + Stereo camera setup and diagnostics + Check camera calibration and hand tracking before playing. + Open setup Storage Measuring storage… This takes a few seconds the first time. @@ -2682,6 +2723,26 @@ %d app %d apps + Bare-hand controllers + Use the glasses cameras to aim with your hands, pinch to click and close your hand to grab in VR. Gamepad sticks move and turn. Replaces Joy-Con position tracking. May lag or lose tracking during games. + Enable Bare-hand controllers under Luma Ultra cameras in Tracking. Show open hands first. + Shared Luma Ultra calibration + Using the shared Luma Ultra base. Calibrate your own glasses to verify their accuracy. + Measured calibration verified + Validation required + Hand controllers become available after the measured distance check passes. + Tracking lost + Look around slowly in a well-lit room.\nKeep the tracking cameras clear and face furniture or other visible detail. + Still stuck? On your phone: Glasses → Tracking → Open setup → Show diagnostics → Restart tracking. + Glasses disconnected + Check the USB connection and reconnect the glasses.\nAccept the USB-access prompt on your phone if it appears. + Once connected, look around slowly in a well-lit room to restore tracking. + Recenter needed + Tracking has returned in a new position.\nLook forward, then tap Recenter on your phone. + You can also find Recenter in Glasses → Tracking → Open setup. Your saved camera calibration is kept. + Hold still for a moment + Recenter is in progress.\nKeep the glasses steady while tracking settles. + This screen closes automatically when head tracking is ready. Boot movie Movie DroidDeck · %1$d fps @@ -2699,4 +2760,147 @@ Converting %1$s for Steam. Keep DroidDeck open. This device cannot decode that video. Could not import that movie + Steady hand aim + Aim from your shoulder through your palm. Turn off for wrist-controlled rotation. + Spatial setup + Waiting for tracking… + Left and right tracking cameras + Camera synchronization + Ready + Waiting for camera and head tracking to line up. Keep the glasses connected. + 1. Prepare the board + Print at actual size + Each square must measure 30 mm (1.181 in). Mount the sheet flat on a rigid surface in a well-lit area. + Print board + 2. Capture different views + Keep the board stationary + Move the glasses closer, farther and sideways. Turn them left/right, angle them up/down, and tilt them sideways. Keep the board in both cameras and pause briefly before each capture. + Start new calibration + Waiting for camera synchronization. + Start a new calibration to collect views. + Keep the board visible in both previews. Capture at least 24 sharp views from different angles. + Capturing… + Capture board view + Calculate camera alignment + Calculating… + Calculate calibration + 3. Check the distance + Measured distance + Start with 12 in or 30 cm so the printed markers are easier to detect. Choose the exact measurement you will use. + Left camera to board center + Checking distance… + Validate distance + Diagnostics + Show diagnostics + Camera timing and tracking recovery tools. + Camera timing + Hand input + Waiting for camera timing. + Frames + GPU hand inference + CPU is the default. GPU is experimental and can cause SteamVR to restart. This choice resets when tracking restarts. + Lite hand models + Use the Lite palm detector and Lite hand landmarks. Check aiming, pinch and grab accuracy. Resets when tracking restarts. + Automatic hand input rate + Adjust input to processing speed. Resets when tracking restarts. + Limit hand input rate + Use half the camera frames. Turn off to compare the full rate. Resets when tracking restarts. + Diagnostic capture + Save one stereo frame locally. Images are saved only when requested. + Save frame + Restart tracking + Use if tracking does not recover in a well-lit area. A restart requires a new tracking origin. + Restart + Restart tracking? + Unsaved calibration views will be lost. Keep the glasses still afterward and recenter when tracking returns. + %1$d / 24 views captured + Capture paused: %1$s + Measure %1$s. Show the complete board in both previews, then hold still. + %1$.1f Hz • frame age %2$.1f ms • processing %3$.1f ms + Input limit %1$.1f Hz • %2$.0f%% of camera frames. Head tracking stays at full rate. + %1$d processed • %2$d dropped • %3$d skipped by input limit + DroidDeck ChArUco 30 mm + DroidDeck - Luma Ultra calibration + Print at 100% / Actual size. Each square: 30 mm (1.181 in). + Keep the board flat and stationary; move the glasses between captures. + Scale check: 100 mm (3.937 in) between ticks + 12 in (30.48 cm) + 30 cm (11.81 in) + 20 in (50.8 cm) + 50 cm (19.69 in) + Disabled + Waiting for stable tracking + Disconnected + Hand controllers are off + Positional tracking is off or glasses are disconnected + Recenter requested — hold still while tracking stabilizes + Tracking lost — face a well-lit area with visible detail + Tracking origin changed — tap Recenter, then hold still + 6DoF active + Connect Luma Ultra and enable positional tracking. + Calibration verified for this connection. + Calibration verified and saved. + Waiting for stereo cameras + Waiting for hand tracking + Keep the 5 × 7 board stationary. Capture 24+ views while moving and rotating the glasses. + Waiting for the next camera image. Hold the glasses still. + Checking the next camera image. Keep the full board visible and hold still. + Start calibration first + No fresh camera image arrived. Check the glasses connection and camera previews, then retry. + Camera clock reset + Tracking frame changed. Your views are saved for recalculation. Recenter, then start a new set to capture more views. + device calibration loaded + Luma Ultra base calibration loaded + calibration required + Tap Start new calibration first. + Recenter is waiting for steady tracking. Hold still for a moment. + Tracking changed. Tap Recenter once, then hold still before capturing. + Capture rejected: head tracking was out of sync, or it changed during capture. Hold still and try again. + Calculate camera alignment before checking the distance. + camera processing failed + Head tracking changed during hand detection + Waiting for camera and head synchronization + No wrists detected. Keep your Joy-Con grips in front of the glasses + No hands detected. Show open palms in front of the glasses + Wrists visible in only one camera; keep your grips in the shared view + Hands visible in only one camera; keep both palms in the shared view + Both cameras see hands, but left/right matching is ambiguous + Hands detected, but stereo depth is inconsistent + Wrist position rejected by stereo or motion checks + Stereo points detected, but palm geometry is inconsistent + Complete calibration and the distance check to enable hands + Waiting for stable head tracking; recenter if requested + Camera observation is too old; waiting for a fresh pair + Fit %1$.2f px. Measure your selected distance from the left camera to the board center, then validate. + OpenCV unavailable: %1$s + %1$d saved views restored. Calculate calibration to retry, or start a new set to capture more. + Captured %1$d / 24 views. Keep the board fixed; move the glasses for the next view. + Capture rejected: %1$d / 12 required corners visible in both cameras. Show more of the board, hold still, then try again. + Distance check could not finish: %1$s. Try again. + Hand detection unavailable: %1$s. Change CPU/GPU or toggle hand controllers to retry. + Hand detection exceeded %1$d ms; observation discarded + %1$d / 2 Joy-Con wrist positions measured by stereo + %1$d / 2 palms tracked; pinch ready: %2$d; grip ready: %3$d + Saved diagnostic capture to %1$s + Hand tracking stopped: %1$s + Stereo %1$d×%2$d; %3$s + Head tracking and the board disagree by %1$s (limit 5 cm / 2 in). Keep the board fixed and wait for steady tracking before starting a new set. Turn and tilt the glasses gently; pause before each capture. + Capture at least 24 varied views of the stationary board. + Rotate the glasses through both yaw and pitch; translation alone cannot calibrate camera alignment. + Implausible camera baseline + Move your head through more varied orientations. + Invalid camera-to-head rotation + Camera-to-head alignment is inconsistent. + Calibration could not finish. %1$s Your captured views are saved. + Held-out reprojection error %1$.2f px exceeds 2 px. Recalibrate. + %1$d / 24 checkerboard corners detected in both cameras. Keep the full board visible and hold still. If it is already visible, select 12 in or 30 cm and measure that closer distance before retrying. + The board is visible, but its depth could not be measured reliably. Hold the glasses still and keep the board flat and well lit, then retry. + The camera measurement was invalid. Hold still and try again. + Distance check passed. + Recheck the distance from the left camera to the board center, then retry. + Cameras measured %1$s; selected distance %2$s. %3$s + Wait for both camera previews before starting calibration. + Saved views can be recalculated. Start a new calibration to capture in the current tracking frame. + Hand model checksum mismatch + OpenCV could not load diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheckTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheckTest.kt new file mode 100644 index 0000000000..e28b5b7d77 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/CalibrationDistanceCheckTest.kt @@ -0,0 +1,66 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test +import java.util.Locale +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import com.droiddeck.launcher.R + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class CalibrationDistanceCheckTest { + private val context get() = RuntimeEnvironment.getApplication() + private fun board(z: Float)=List(24) { i -> SpatialVector((i%4-1.5f)*.03f,(i/4-2.5f)*.03f,z) } + + @Test + @Config(qualifiers = "fr") + fun rejectedCaptureExplainsTheProblemInTheSelectedLanguage() { + val result = CalibrationDistanceCheck.evaluate(context, .3048f, 3, null) + assertFalse(result.accepted) + assertEquals(context.getString(R.string.spatial_distance_corners, 3), result.message) + assertFalse(result.message.contains("checkerboard corners detected")) + assertTrue(result.message.contains("3 / 24")) + } + + @Test fun missingAndPartialBoardsExplainVisibilityRatherThanDistance() { + for (count in listOf(0,12,23)) { + val result=CalibrationDistanceCheck.evaluate(context,.508f,count,null) + assertFalse(result.accepted) + assertTrue(result.message.contains("$count / 24")) + } + } + @Test fun fullBoardWithRejectedStereoGeometryCannotPass() { + assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,null).accepted) + assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.508f).dropLast(1)).accepted) + assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.508f).toMutableList().also { + it[0]=SpatialVector(z=Float.NaN) + }).accepted) + } + @Test fun preservesFiveCentimeterToleranceAndReportsBothUnits() { + val locale=Locale.getDefault() + try { + Locale.setDefault(Locale.US) + assertTrue(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.508f)).accepted) + assertTrue(CalibrationDistanceCheck.evaluate(context,.3048f,24,board(.3048f)).accepted) + assertFalse(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.3048f)).accepted) + assertTrue(CalibrationDistanceCheck.evaluate(context,.508f,24,board(.557f)).accepted) + val result=CalibrationDistanceCheck.evaluate(context,.508f,24,board(.60f)) + assertFalse(result.accepted) + assertTrue(result.message.contains("60.0 cm (23.62 in)")) + assertTrue(result.message.contains("50.8 cm (20.00 in)")) + } finally { Locale.setDefault(locale) } + } + @Test fun checksCameraToCenterDistanceRatherThanOnlyForwardDepth() { + val points=board(.4f).map { it+SpatialVector(x=.3f) } + assertTrue(CalibrationDistanceCheck.evaluate(context,.5f,24,points).accepted) + assertFalse(CalibrationDistanceCheck.evaluate(context,.4f,24,points).accepted) + } + @Test fun rejectsInvalidRequestedDistances() { + for(distance in listOf(0f,Float.NaN,Float.POSITIVE_INFINITY)) { + assertThrows(IllegalArgumentException::class.java) { CalibrationDistanceCheck.evaluate(context,distance,24,board(.5f)) } + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/CalibrationObservationDataTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/CalibrationObservationDataTest.kt new file mode 100644 index 0000000000..4452f91cf3 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/CalibrationObservationDataTest.kt @@ -0,0 +1,47 @@ +package com.droiddeck.launcher.glasses + +import org.json.JSONArray +import org.json.JSONObject +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk=[28],manifest=Config.NONE) +class CalibrationObservationDataTest { + private fun view(count: Int=24) = JSONObject().put("objects",JSONArray((0 until count).map { + JSONArray(listOf((it%4+1)*0.03,(it/4+1)*0.03,0.0)) + })).put("left",JSONArray((0 until count).map { JSONArray(listOf(100.0+it,200.0)) })) + .put("right",JSONArray((0 until count).map { JSONArray(listOf(80.0+it,200.0)) })) + .put("head",JSONArray(listOf(0.1,0.2,0.3,1.0,0.0,0.0,0.0))) + + @Test fun preservesPartialBoardCorrespondencesAndHeadPose() { + for(count in listOf(12,20,24)) { + val restored=CalibrationObservationData.parse(JSONObject(view(count).toString())) + assertEquals(count,restored.objects.size) + assertEquals(20.0,restored.left.last()[0]-restored.right.last()[0],0.0) + assertEquals(SpatialVector(.1f,.2f,.3f),restored.head.position) + assertEquals(SpatialRotation(),restored.head.rotation) + } + } + @Test fun rejectsTruncatedOrMismatchedCorrespondences() { + assertThrows(IllegalArgumentException::class.java) { CalibrationObservationData.parse(view(11)) } + assertThrows(IllegalArgumentException::class.java) { CalibrationObservationData.parse(view(25)) } + assertThrows(IllegalArgumentException::class.java) { + CalibrationObservationData.parse(view().put("right",view(20).getJSONArray("right"))) + } + assertThrows(IllegalArgumentException::class.java) { + CalibrationObservationData.parse(view().also { it.getJSONArray("left").put(0,JSONArray(listOf(1.0))) }) + } + } + @Test fun rejectsInvalidHeadRotationAndFloatOverflow() { + assertThrows(IllegalStateException::class.java) { + CalibrationObservationData.parse(view().put("head",JSONArray(listOf(0,0,0,0,0,0,0)))) + } + assertThrows(IllegalStateException::class.java) { + CalibrationObservationData.parse(view().put("head",JSONArray(listOf(1e100,0,0,1,0,0,0)))) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt new file mode 100644 index 0000000000..d40441552d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/Glasses3dRoutingTest.kt @@ -0,0 +1,450 @@ +package com.droiddeck.launcher.glasses + +import android.content.Context +import android.os.Handler +import android.os.Looper +import kotlinx.coroutines.flow.MutableStateFlow +import org.junit.Assert.* +import org.junit.After +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +@LooperMode(LooperMode.Mode.PAUSED) +class Glasses3dRoutingTest { + private val handler = Handler(Looper.getMainLooper()) + private val commands = mutableListOf>() + private val hardwareMessages = mutableListOf() + private lateinit var stateBefore: GlassesState + private lateinit var settingsBefore: GlassesSettings + private val supportedModels: List = + listOf("One", "Lite", "Pro", "Pro 2", "Luma", "Luma Pro", "Luma Cyber", "Luma Ultra", "Beast") + .map { VitureProtocol.sdkModel(it)!! } + listOf( + RayNeoModel.model(0x1bbb, 0xaf50, "RayNeo Air 4 Pro")!!, + RayNeoModel.model(0x3941, 0xaf50, "RayNeo GT")!!, + RayNeoModel.model(0x3941, 0xaf50, "RayNeo GT MAX")!!, + XrealModel, + ) + private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true } + + @Before fun prepare() { + stateBefore = Glasses.state.value + settingsBefore = Glasses.settings.value + val context = RuntimeEnvironment.getApplication() + context.getSharedPreferences("glasses", Context.MODE_PRIVATE).edit().clear().commit() + field("app").set(null, context) + field("handler").set(null, handler) + field("model").set(null, VitureProtocol.model(0x1019, null)) + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = GlassesState(connected = true, controllable = true, + displayId = 2, width = 1920, height = 1080) + @Suppress("UNCHECKED_CAST") + val settings = field("_settings").get(null) as MutableStateFlow + settings.value = GlassesSettings(gameOnGlasses = false) + field("link").set(null, object : GlassesLink { + override val hasImu = false + override fun send(msgId: Int, payload: ByteArray): Boolean { + hardwareMessages += msgId + if (msgId == VitureProtocol.MSG_DISPLAY) + commands += (payload[0].toInt() and 255) to Glasses.settings.value.gameOnGlasses + return true + } + override fun close() {} + }) + } + + @After fun cleanUp() { + handler.removeCallbacksAndMessages(null) + field("link").set(null, null) + (field("modeState").get(null) as GlassesModeState).apply { manual(); sent(false, 0) } + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = stateBefore + @Suppress("UNCHECKED_CAST") + val settings = field("_settings").get(null) as MutableStateFlow + settings.value = settingsBefore + } + + @Test fun lumaJoyConsDefaultOffPersistAndExcludeBareHands() { + assertFalse(GlassesSettings().joyConTracking) + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = state.value.copy(supportsSpatial = true) + @Suppress("UNCHECKED_CAST") + val settings = field("_settings").get(null) as MutableStateFlow + Glasses.setJoyConTracking(true) + shadowOf(Looper.getMainLooper()).idle() + assertFalse(Glasses.settings.value.joyConTracking) + settings.value = settings.value.copy(positionalTracking = true, handControllers = true) + Glasses.setJoyConTracking(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.joyConTracking) + assertFalse(Glasses.settings.value.handControllers) + val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE) + assertTrue(prefs.getBoolean("joyConTracking", false)) + val loaded = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true }.invoke(Glasses) as GlassesSettings + assertTrue(loaded.joyConTracking) + Glasses.setHandControllers(true) + shadowOf(Looper.getMainLooper()).idle() + assertFalse(Glasses.settings.value.joyConTracking) + assertTrue(Glasses.settings.value.handControllers) + SpatialTracking.setControllers(false, false) + } + + @Test fun otherGlassesRejectSpatialEnableAndRestartWithoutClosingTheirLink() { + val before = Glasses.settings.value + val link = field("link").get(null) + Glasses.setPositionalTracking(true) + Glasses.restartSpatialTracking() + shadowOf(Looper.getMainLooper()).idle() + assertEquals(before, Glasses.settings.value) + assertSame(link, field("link").get(null)) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun manual3dSelectsAndSavesGlassesOutputBeforeSwitchingTheDisplay() { + Glasses.set3d(true) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(0x32 to true), commands) + assertTrue(Glasses.settings.value.gameOnGlasses) + val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE) + assertTrue(prefs.getBoolean("gameOnGlasses", false)) + } + + @Test fun nativeThirtyHzIsSavedWithoutSendingAFabricatedHardwareMode() { + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + Glasses.setGameOnGlasses(true) + shadowOf(Looper.getMainLooper()).idle() + state.value = state.value.copy(supports30Hz = true) + + Glasses.setRefreshHz(30) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(30, Glasses.settings.value.refreshHz) + assertTrue(hardwareMessages.isEmpty()) + + state.value = state.value.copy(sbs = true, width = 3840) + Glasses.setSbsHz(30) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(30, Glasses.settings.value.sbsHz) + assertTrue(hardwareMessages.isEmpty()) + val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true } + .invoke(Glasses) as GlassesSettings + assertEquals(30, saved.refreshHz) + assertEquals(30, saved.sbsHz) + } + + @Test fun unsupportedThirtyHzRequestsLeavePreferencesAndHardwareUnchanged() { + val before = Glasses.settings.value + Glasses.setRefreshHz(30) + Glasses.setSbsHz(30) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(before, Glasses.settings.value) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun automaticSteamVr3dAlsoSelectsGlassesOutput() { + Glasses.set3dForVr(true) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(0x32 to true), commands) + assertTrue(Glasses.settings.value.gameOnGlasses) + } + + @Test fun returningTo2dKeepsTheGameOnGlasses() { + Glasses.set3d(true) + shadowOf(Looper.getMainLooper()).idle() + Glasses.set3d(false) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(0x32 to true, 0x34 to true), commands) + assertTrue(Glasses.settings.value.gameOnGlasses) + } + + @Test fun turningOff3dDoesNotEnableGlassesOutput() { + Glasses.set3d(false) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(0x34 to false), commands) + assertFalse(Glasses.settings.value.gameOnGlasses) + } + + @Test fun turningOffGlassesOutputRestores2dOnEverySupportedModel() { + for (model in supportedModels) { + selectModel(model) + Glasses.set3dof(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.screen3dof) + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = state.value.copy(sbs = true, width = 3840) + commands.clear() + + Glasses.setGameOnGlasses(false) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(model.mode(120, false) to true), commands) + assertFalse(Glasses.settings.value.gameOnGlasses) + assertFalse(Glasses.settings.value.screen3dof) + assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d) + val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE) + assertFalse(prefs.getBoolean("gameOnGlasses", true)) + } + } + + @Test fun turningOffGlassesOutputCancelsAnUnconfirmedStereoSwitch() { + Glasses.set3d(true) + shadowOf(Looper.getMainLooper()).idle() + assertFalse(Glasses.state.value.sbs) + assertTrue(Glasses.state.value.switching3d) + + Glasses.setGameOnGlasses(false) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(0x32 to true, 0x34 to true), commands) + assertFalse(Glasses.state.value.switching3d) + assertFalse(Glasses.settings.value.gameOnGlasses) + } + + @Test fun turningOffGlassesOutputTakesOwnershipFromAutomaticVr() { + Glasses.set3dForVr(true) + shadowOf(Looper.getMainLooper()).idle() + Glasses.setGameOnGlasses(false) + shadowOf(Looper.getMainLooper()).idle() + Glasses.set3dForVr(false) + shadowOf(Looper.getMainLooper()).idle() + + assertEquals(listOf(0x32 to true, 0x34 to true), commands) + assertFalse(Glasses.state.value.switching3d) + assertFalse(Glasses.settings.value.gameOnGlasses) + } + + @Test fun togglingGlassesOutputIn2dDoesNotSendDisplayCommands() { + Glasses.setGameOnGlasses(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.gameOnGlasses) + Glasses.setGameOnGlasses(false) + shadowOf(Looper.getMainLooper()).idle() + + assertFalse(Glasses.settings.value.gameOnGlasses) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun turningOffGlassesOutputDisablesVirtualScreenAndSavesTheChoice() { + selectModel(supportedModels.first()) + Glasses.set3dof(true) + shadowOf(Looper.getMainLooper()).idle() + Glasses.setGameOnGlasses(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.screen3dof) + + Glasses.setGameOnGlasses(false) + shadowOf(Looper.getMainLooper()).idle() + + assertFalse(Glasses.settings.value.screen3dof) + assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d) + val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true } + .invoke(Glasses) as GlassesSettings + assertFalse(saved.gameOnGlasses) + assertFalse(saved.screen3dof) + assertEquals(GlassesSettings.PICTURE_AUTO, saved.picture3d) + + Glasses.setGameOnGlasses(true) + shadowOf(Looper.getMainLooper()).idle() + assertFalse(Glasses.settings.value.screen3dof) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun turningOffGlassesOutputDisablesVirtualScreenWithoutDeviceControl() { + selectModel(supportedModels.first()) + Glasses.set3dof(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.screen3dof) + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = state.value.copy(connected = false, supportsScreen3dof = false) + + Glasses.setGameOnGlasses(false) + shadowOf(Looper.getMainLooper()).idle() + + assertFalse(Glasses.settings.value.gameOnGlasses) + assertFalse(Glasses.settings.value.screen3dof) + assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun enabling3dofRoutesFlatContentWithoutSendingAStereoCommandAndSurvivesReload() { + for (model in supportedModels) { + selectModel(model) + Glasses.set3dof(true) + shadowOf(Looper.getMainLooper()).idle() + + assertTrue(hardwareMessages.isEmpty()) + assertFalse(Glasses.state.value.sbs) + assertFalse(Glasses.state.value.switching3d) + assertTrue(Glasses.settings.value.screen3dof) + assertTrue(Glasses.settings.value.gameOnGlasses) + val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true } + .invoke(Glasses) as GlassesSettings + assertTrue(saved.screen3dof) + assertTrue(saved.gameOnGlasses) + } + } + + @Test fun stereoAnd3dofCanBeToggledIndependentlyOnEverySupportedModel() { + for (model in supportedModels) { + selectModel(model) + Glasses.set3dof(true) + Glasses.set3d(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.screen3dof) + + Glasses.set3d(false) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.settings.value.screen3dof) + assertEquals(listOf(model.mode(60, true) to true, model.mode(120, false) to true), commands) + + commands.clear() + hardwareMessages.clear() + Glasses.set3dof(false) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(hardwareMessages.isEmpty()) + assertFalse(Glasses.settings.value.screen3dof) + assertEquals(GlassesSettings.PICTURE_AUTO, Glasses.settings.value.picture3d) + assertTrue(Glasses.settings.value.gameOnGlasses) + } + } + + @Test fun enabling3dofWithoutHeadTrackingSupportLeavesSettingsUnchanged() { + val before = Glasses.settings.value + Glasses.set3dof(true) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(before, Glasses.settings.value) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun resolutionsPersistIndependentlyAndOnlyTheActiveProfileChangesHardware() { + selectModel(VitureProtocol.sdkModel("Luma Ultra")!!) + Glasses.setResolution(GlassesDisplayProfile.THREE_D, "1920x1080") + Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1200") + shadowOf(Looper.getMainLooper()).idle() + assertTrue(hardwareMessages.isEmpty()) + + Glasses.setResolution(GlassesDisplayProfile.TWO_D, "1920x1080") + shadowOf(Looper.getMainLooper()).idle() + assertEquals(listOf(0x34 to false), commands) + assertEquals(120, Glasses.settings.value.refreshHz) + assertEquals(60, Glasses.settings.value.sbsHz) + val saved = Glasses::class.java.getDeclaredMethod("load").apply { isAccessible = true } + .invoke(Glasses) as GlassesSettings + assertEquals("1920x1080", saved.resolution2d) + assertEquals("1920x1080", saved.resolution3d) + assertEquals("1920x1200", saved.resolutionVr) + assertEquals(listOf(VitureProtocol.MSG_DISPLAY), hardwareMessages) + } + + @Test fun vrResolutionIsAppliedAndTheOrdinaryResolutionIsRestoredAfterStopping() { + selectModel(VitureProtocol.sdkModel("Luma Ultra")!!) + Glasses.setResolution(GlassesDisplayProfile.TWO_D, "1920x1080") + Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1200") + shadowOf(Looper.getMainLooper()).idle() + commands.clear() + Glasses.setVrActive(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.state.value.vrActive) + assertEquals(listOf(0x44 to false), commands) + Glasses.setVrActive(false) + shadowOf(Looper.getMainLooper()).idle() + assertFalse(Glasses.state.value.vrActive) + assertEquals(listOf(0x44 to false, 0x34 to false), commands) + } + + @Test fun vrResolutionUsesStereoCommandsAndRestoresThePreVrLayoutOnce() { + selectModel(VitureProtocol.sdkModel("Luma Ultra")!!) + Glasses.setGameOnGlasses(true) + Glasses.setAuto3d(true) + Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1080") + shadowOf(Looper.getMainLooper()).idle() + Glasses.setVrActive(true) + Glasses.set3dForVr(true) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(listOf(0x32 to true), commands) + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = state.value.copy(sbs = true, width = 3840, switching3d = false) + (field("modeState").get(null) as GlassesModeState).observe(true, 0) + + Glasses.setSbsHz(90) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(0x35 to true, commands.last()) + Glasses.setVrActive(false) + Glasses.set3dForVr(false) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(listOf(0x32 to true, 0x35 to true, 0x44 to true), commands) + } + + @Test fun invalidResolutionCannotChangePreferencesOrSendDeviceCommands() { + selectModel(VitureProtocol.sdkModel("Pro")!!) + val before = Glasses.settings.value + for (value in listOf("1920x1200", "3840x1080", "-1x1080", "unknown")) + Glasses.setResolution(GlassesDisplayProfile.TWO_D, value) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(before, Glasses.settings.value) + assertTrue(hardwareMessages.isEmpty()) + } + + @Test fun startingVrDuringAStereoSwitchDoesNotSendAFlatMode() { + selectModel(VitureProtocol.sdkModel("Luma Ultra")!!) + Glasses.setResolution(GlassesDisplayProfile.VR, "1920x1080") + Glasses.set3d(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.state.value.switching3d) + Glasses.setVrActive(true) + shadowOf(Looper.getMainLooper()).idle() + assertEquals(listOf(0x42 to true, 0x32 to true), commands) + } + + @Test fun reconnectRestoresASavedResolutionEvenWhenRefreshAlreadyMatches() { + selectModel(VitureProtocol.sdkModel("Luma Ultra")!!) + Glasses.setResolution(GlassesDisplayProfile.TWO_D, "1920x1080") + shadowOf(Looper.getMainLooper()).idle() + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = state.value.copy(width = 1920, height = 1200, hz = 120f) + field("glassesMode").setInt(null, 0) + field("autoModeSent").setBoolean(null, false) + field("lastModeSentAt").setLong(null, -10_000L) + commands.clear() + Glasses::class.java.getDeclaredMethod("applyMode", Boolean::class.javaPrimitiveType) + .apply { isAccessible = true }.invoke(Glasses, false) + assertEquals(listOf(0x34 to false), commands) + } + + @Test fun defaultVrProfileDoesNotSendExtraDisplayCommands() { + selectModel(VitureProtocol.sdkModel("Luma Ultra")!!) + Glasses.setVrActive(true) + Glasses.setVrActive(false) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(hardwareMessages.isEmpty()) + } + + private fun selectModel(model: GlassesModel) { + field("model").set(null, model) + @Suppress("UNCHECKED_CAST") + val state = field("_state").get(null) as MutableStateFlow + state.value = state.value.copy(model = model.name, supportsScreen3dof = true, resolutions = model.resolutions) + @Suppress("UNCHECKED_CAST") + val settings = field("_settings").get(null) as MutableStateFlow + settings.value = GlassesSettings(gameOnGlasses = false, headTracking = false) + assertFalse(settings.value.screen3dof) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesDisplayModesTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesDisplayModesTest.kt new file mode 100644 index 0000000000..a79b6ac3b3 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesDisplayModesTest.kt @@ -0,0 +1,62 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class GlassesDisplayModesTest { + private val fullHd = GlassesResolution(1920, 1080) + private val tall = GlassesResolution(1920, 1200) + private val ultra = VitureProtocol.sdkModel("Luma Ultra")!! + private val state = GlassesState(resolutions = ultra.resolutions) + + @Test fun separateProfilesRetainTheirOwnResolutions() { + val settings = GlassesSettings(resolution2d = fullHd.key, resolution3d = tall.key, resolutionVr = fullHd.key) + assertEquals(fullHd, GlassesDisplayModes.selected(settings, state)) + assertEquals(tall, GlassesDisplayModes.selected(settings, state.copy(sbs = true))) + for (stereo in listOf(false, true)) + assertEquals(fullHd, GlassesDisplayModes.selected(settings, state.copy(sbs = stereo, vrActive = true))) + } + + @Test fun automaticVrInheritsTheActiveLayoutAndDefaultsKeepNativeBehavior() { + val settings = GlassesSettings(resolution2d = fullHd.key, resolution3d = tall.key) + assertEquals(fullHd, GlassesDisplayModes.selected(settings, state.copy(vrActive = true))) + assertEquals(tall, GlassesDisplayModes.selected(settings, state.copy(sbs = true, vrActive = true))) + assertNull(GlassesDisplayModes.selected(GlassesSettings(), state)) + assertNull(GlassesDisplayModes.selected(GlassesSettings(), state.copy(sbs = true, vrActive = true))) + } + + @Test fun anotherHeadsetDoesNotReceiveAnUnsupportedSavedResolution() { + val settings = GlassesSettings(resolution2d = tall.key, resolutionVr = tall.key) + assertNull(GlassesDisplayModes.selected(settings, state.copy(resolutions = listOf(fullHd)))) + assertNull(GlassesDisplayModes.selected(settings, state.copy(resolutions = emptyList(), vrActive = true))) + assertEquals(tall, GlassesDisplayModes.selected(settings, state)) + } + + @Test fun ultraResolutionsMapToVendorCommandsAtEverySupportedRefresh() { + for ((hz, code) in listOf(60 to 0x31, 90 to 0x33, 120 to 0x34)) { + assertEquals(code, ultra.mode(hz, false, fullHd)) + assertEquals(code + 0x10, ultra.mode(hz, false, tall)) + } + for ((hz, code) in listOf(60 to 0x32, 90 to 0x35)) { + assertEquals(code, ultra.mode(hz, true, fullHd)) + assertEquals(code + 0x10, ultra.mode(hz, true, tall)) + } + assertEquals(0x41, ultra.mode(30, false, tall)) + assertEquals(0x42, ultra.mode(30, true, tall)) + } + + @Test fun olderModelsKeepTheirNativeResolutionAndStereoRateLimits() { + for (name in listOf("One", "Pro", "Pro 2")) { + val model = VitureProtocol.sdkModel(name)!! + assertEquals(listOf(fullHd), model.resolutions) + assertEquals(0x34, model.mode(120, false, tall)) + assertEquals(0x32, model.mode(90, true, tall)) + } + for (name in listOf("Luma", "Luma Pro", "Luma Ultra", "Beast")) { + val model = VitureProtocol.sdkModel(name)!! + assertEquals(listOf(fullHd, tall), model.resolutions) + assertEquals(0x44, model.mode(120, false)) + assertEquals(if (model.sbs90) 0x45 else 0x42, model.mode(90, true)) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuCaptureTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuCaptureTest.kt new file mode 100644 index 0000000000..e2a5f683d7 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuCaptureTest.kt @@ -0,0 +1,149 @@ +package com.droiddeck.launcher.glasses + +import android.app.Activity +import android.app.Application +import android.app.Dialog +import android.app.Presentation +import android.graphics.SurfaceTexture +import android.hardware.display.DisplayManager +import android.view.Choreographer +import android.view.Surface +import android.view.View +import android.view.WindowManager +import android.widget.FrameLayout +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.android.controller.ActivityController +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode +import org.robolectric.shadows.ShadowDisplayManager + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [29], manifest = Config.NONE, application = Application::class) +@LooperMode(LooperMode.Mode.PAUSED) +class GlassesMenuCaptureTest { + private lateinit var controller: ActivityController + private lateinit var activity: Activity + private val dialogs = mutableListOf() + + @Before fun setUp() { + controller = Robolectric.buildActivity(Activity::class.java).setup().visible() + activity = controller.get() + activity.window.decorView.layout(0, 0, 1920, 1080) + } + + @After fun tearDown() { + dialogs.forEach { it.dismiss() } + controller.pause().stop().destroy() + } + + @Test fun onlyTheActivityAndItsOwnDialogAreIncludedOnce() { + val own = dialog(activity) + val otherController = Robolectric.buildActivity(Activity::class.java).setup().visible() + val other = otherController.get() + val otherDialog = dialog(other) + try { + val decor = activity.window.decorView + val roots = GlassesMenuCapture.captureRoots(activity, + listOf(other.window.decorView, own, otherDialog, decor, own)) + assertEquals(listOf(decor, own), roots) + } finally { + dialogs.removeAll { if (it.ownerActivity === other) { it.dismiss(); true } else false } + otherController.pause().stop().destroy() + } + } + + @Test fun secureActivityProducesNoRootsAndSecureDialogsAreExcluded() { + val secure = dialog(activity) + val params = secure.layoutParams as WindowManager.LayoutParams + params.flags = params.flags or WindowManager.LayoutParams.FLAG_SECURE + assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, listOf(secure))) + + activity.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE) + assertTrue(GlassesMenuCapture.captureRoots(activity, listOf(secure)).isEmpty()) + activity.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) + assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, listOf(secure))) + } + + @Test fun systemWindowsAndPresentationsOnOtherDisplaysAreExcluded() { + val own = dialog(activity) + (own.layoutParams as WindowManager.LayoutParams).type = WindowManager.LayoutParams.TYPE_APPLICATION_OVERLAY + val displayId = ShadowDisplayManager.addDisplay("w1920dp-h1080dp") + val display = activity.getSystemService(DisplayManager::class.java).getDisplay(displayId) + val presentation = Presentation(activity, display).apply { + setContentView(FrameLayout(context)) + show() + }.also(dialogs::add) + try { + assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, + listOf(own, presentation.window!!.decorView))) + } finally { + presentation.dismiss() + dialogs.remove(presentation) + ShadowDisplayManager.removeDisplay(displayId) + } + } + + @Test + @Config(sdk = [26]) + fun olderAndroidCapturesOnlyTheActivityDecor() { + val own = dialog(activity) + assertEquals(listOf(activity.window.decorView), GlassesMenuCapture.captureRoots(activity, listOf(own))) + } + + @Test fun captureSizesPreserveOrientationAndNeverUpscale() { + assertEquals(1920 to 1080, GlassesMenuCapture.captureSize(3840, 2160)) + assertEquals(1080 to 1920, GlassesMenuCapture.captureSize(2160, 3840)) + assertEquals(1200 to 1800, GlassesMenuCapture.captureSize(1200, 1800)) + val fold = GlassesMenuCapture.captureSize(2152, 1812)!! + assertEquals(1920, fold.first) + assertEquals(2152.0 / 1812.0, fold.first.toDouble() / fold.second, 0.001) + assertNull(GlassesMenuCapture.captureSize(0, 1000)) + assertNull(GlassesMenuCapture.captureSize(1000, -1)) + } + + @Test fun repeatedSurfaceFailureStopsOnceAndDoesNotRetryAfterStop() { + var sizes = 0 + var failures = 0 + val capture = GlassesMenuCapture(activity, { _, _ -> sizes++ }, { failures++ }) + val input = SurfaceTexture(0) + val target = Surface(input) + target.release() + try { + capture.attach(input, target) + capture.start() + for (time in listOf(1L, 33_333_335L, 66_666_669L, 100_000_003L)) { + Choreographer.getInstance().removeFrameCallback(capture) + capture.doFrame(time) + } + assertEquals(1, failures) + assertEquals(0, sizes) + assertFalse(pending(capture)) + } finally { + capture.stop() + input.release() + } + } + + @Test fun stoppingRejectsAnAlreadyDispatchedFrameWithoutRescheduling() { + val capture = GlassesMenuCapture(activity, { _, _ -> fail("Stopped capture changed its size") }) + capture.start() + capture.stop() + capture.doFrame(1L) + assertFalse(pending(capture)) + } + + private fun dialog(owner: Activity): View = Dialog(owner).apply { + setOwnerActivity(owner) + setContentView(FrameLayout(context)) + show() + }.also(dialogs::add).window!!.decorView + + private fun pending(capture: GlassesMenuCapture): Boolean = + GlassesMenuCapture::class.java.getDeclaredField("framePending").apply { isAccessible = true }.getBoolean(capture) +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuControllerTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuControllerTest.kt new file mode 100644 index 0000000000..3c539f0ef0 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuControllerTest.kt @@ -0,0 +1,340 @@ +package com.droiddeck.launcher.glasses + +import android.app.Activity +import android.app.Application +import android.hardware.display.DisplayManager +import android.view.Display +import android.view.WindowManager +import com.droiddeck.launcher.QuestXrActivity +import com.droiddeck.launcher.SessionActivity +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.android.controller.ActivityController +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode +import org.robolectric.shadows.ShadowDisplayManager + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], application = Application::class, manifest = Config.NONE) +@LooperMode(LooperMode.Mode.PAUSED) +class GlassesMenuControllerTest { + private lateinit var owner: Activity + private lateinit var ownerLifecycle: ActivityController + private lateinit var external: Display + private lateinit var menus: GlassesMenuController + private val displays = mutableListOf() + private val outputs = mutableListOf() + private val subscriptions = mutableListOf() + private val scheduled = ArrayDeque<() -> Unit>() + private var target: Display? = null + private var creationError: RuntimeException? = null + private var onCreateOutput: (FakeOutput) -> Unit = {} + private val saved = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, + headTracking = true, screenWidthDm = 35, screenDistanceDm = 45) + private lateinit var glasses: GlassesState + + @Before fun setUp() { + ownerLifecycle = Robolectric.buildActivity(Activity::class.java).setup() + owner = ownerLifecycle.get() + external = addDisplay() + target = external + glasses = GlassesState(present = true, connected = true, controllable = true, + supportsScreen3dof = true, displayId = external.displayId, width = 1920, height = 1080) + menus = GlassesMenuController(GlassesMenuPose(spatialEnabled = { false }), + display = { target }, observe = { subscriptions += it }, + create = { activity, display, failure -> + creationError?.let { throw it } + FakeOutput(activity, display, failure).also { + outputs += it + onCreateOutput(it) + } + }, schedule = { scheduled.addLast(it) }) + menus.update(glasses, saved) + } + + @After fun tearDown() { + menus.pause(owner) + ownerLifecycle.pause().stop().destroy() + displays.forEach(ShadowDisplayManager::removeDisplay) + } + + @Test fun menusStartOnlyForSupportedControlledExternalOutputWithTrackingSelected() { + val invalid = listOf( + glasses.copy(connected = false) to saved, + glasses.copy(controllable = false) to saved, + glasses.copy(supportsScreen3dof = false) to saved, + glasses.copy(noSignal = true) to saved, + glasses.copy(displayId = Display.INVALID_DISPLAY) to saved, + glasses to saved.copy(gameOnGlasses = false), + glasses to saved.copy(headTracking = false), + glasses to saved.copy(picture3d = GlassesSettings.PICTURE_AUTO), + ) + for ((state, preferences) in invalid) { + menus.update(state, preferences) + menus.resume(owner) + assertTrue(outputs.isEmpty()) + assertTrue(subscriptions.isEmpty()) + } + menus.update(glasses, saved) + assertEquals(1, outputs.size) + assertEquals(listOf(true), subscriptions) + assertEquals(1, outputs.single().shows) + assertEquals(saved, outputs.single().settings) + } + + @Test fun absentDisplayAndThePhoneDisplayNeverCreateAnOutput() { + target = null + menus.resume(owner) + target = owner.windowManager.defaultDisplay + menus.update(glasses, saved) + assertTrue(outputs.isEmpty()) + assertTrue(subscriptions.isEmpty()) + target = external + menus.update(glasses, saved) + assertEquals(1, outputs.size) + } + + @Test fun sessionContentIsExcludedUntilItsMenuIsVisibleAndStalePauseCannotCloseNewOwner() { + menus.resume(owner) + val first = outputs.single() + val session = Robolectric.buildActivity(SessionActivity::class.java).get() + menus.resume(session) + assertEquals(1, first.closes) + assertEquals(1, outputs.size) + + menus.setSessionMenuVisible(session, true) + val overlay = outputs.last() + assertSame(session, overlay.owner) + assertEquals(2, outputs.size) + menus.setSessionMenuVisible(session, false) + assertEquals(1, overlay.closes) + + menus.resume(owner) + val latest = outputs.last() + menus.pause(session) + menus.setSessionMenuVisible(session, true) + assertEquals(0, latest.closes) + assertEquals(3, outputs.size) + } + + @Test fun pauseReleasesSubscriptionAndLateFailureCannotCloseAReplacement() { + menus.resume(owner) + val old = outputs.single() + menus.pause(owner) + menus.pause(owner) + assertEquals(1, old.closes) + assertEquals(listOf(true, false), subscriptions) + + menus.resume(owner) + val current = outputs.last() + old.fail(IllegalStateException("late GL callback")) + assertEquals(0, current.closes) + assertEquals(2, outputs.size) + menus.pause(owner) + assertEquals(1, current.closes) + assertFalse(subscriptions.last()) + } + + @Test fun destroyedActivityCannotRecreateItsOutputAfterCleanup() { + val lifecycle = Robolectric.buildActivity(Activity::class.java).setup() + val destroyed = lifecycle.get() + menus.resume(destroyed) + val output = outputs.single() + lifecycle.pause().stop().destroy() + menus.pause(destroyed) + menus.resume(destroyed) + assertEquals(1, output.closes) + assertEquals(1, outputs.size) + assertFalse(subscriptions.last()) + menus.pause(destroyed) + } + + @Test fun secureFinishingAndImmersiveQuestActivitiesCannotBeCaptured() { + owner.window.addFlags(WindowManager.LayoutParams.FLAG_SECURE) + menus.resume(owner) + assertTrue(outputs.isEmpty()) + owner.window.clearFlags(WindowManager.LayoutParams.FLAG_SECURE) + val quest = Robolectric.buildActivity(QuestXrActivity::class.java).get() + menus.resume(quest) + assertTrue(outputs.isEmpty()) + owner.finish() + menus.resume(owner) + assertTrue(outputs.isEmpty()) + } + + @Test fun settingsReconfigureTheSameOutputAndDisablingTrackingClosesIt() { + menus.resume(owner) + val output = outputs.single() + val changed = saved.copy(screenWidthDm = 50, screenDistanceDm = 60, positionalTracking = true) + menus.update(glasses.copy(sbs = true), changed) + assertEquals(1, outputs.size) + assertEquals(2, output.configurations) + assertEquals(changed, output.settings) + assertTrue(output.state!!.sbs) + assertEquals(listOf(true), subscriptions) + + menus.update(glasses, changed.copy(headTracking = false)) + assertEquals(1, output.closes) + assertFalse(subscriptions.last()) + menus.update(glasses, changed) + assertEquals(2, outputs.size) + assertTrue(subscriptions.last()) + } + + @Test fun displayRemovalAndReplacementCloseOldOutputAndRebindOnlyTheCurrentDisplay() { + menus.resume(owner) + val old = outputs.single() + target = null + menus.update(glasses.copy(displayId = Display.INVALID_DISPLAY), saved) + assertEquals(1, old.closes) + assertFalse(subscriptions.last()) + + target = addDisplay() + menus.update(glasses.copy(displayId = target!!.displayId), saved) + assertEquals(2, outputs.size) + assertSame(target, outputs.last().display) + old.fail(IllegalStateException("removed display")) + assertEquals(0, outputs.last().closes) + } + + @Test fun creationFailureIsLatchedUntilPreferencesChangeWithoutSubscribing() { + creationError = IllegalStateException("no EGL display") + menus.resume(owner) + assertTrue(outputs.isEmpty()) + assertTrue(subscriptions.isEmpty()) + creationError = null + menus.update(glasses, saved) + assertTrue(outputs.isEmpty()) + menus.update(glasses, saved.copy(screenWidthDm = 40)) + assertEquals(1, outputs.size) + assertTrue(subscriptions.last()) + } + + @Test fun configureAndShowExceptionsReleaseOutputAndDoNotEscapeUpdates() { + onCreateOutput = { it.showError = IllegalStateException("window removed") } + menus.resume(owner) + assertEquals(1, outputs.single().closes) + assertEquals(listOf(true, false), subscriptions) + + onCreateOutput = {} + menus.update(glasses, saved.copy(screenWidthDm = 40)) + val next = outputs.last() + next.onConfigure = { throw IllegalStateException("surface lost") } + menus.update(glasses, saved) + assertEquals(1, next.closes) + assertFalse(subscriptions.last()) + menus.update(glasses, saved) + assertEquals(2, outputs.size) + } + + @Test fun synchronousFactoryOrConfigureFailureCannotShowOrSubscribeAClosedOutput() { + onCreateOutput = { it.fail(IllegalStateException("creation callback")) } + menus.resume(owner) + assertEquals(0, outputs.single().shows) + assertEquals(1, outputs.single().closes) + assertFalse(subscriptions.contains(true)) + + onCreateOutput = { output -> output.onConfigure = { output.fail(IllegalStateException("configure callback")) } } + menus.update(glasses, saved.copy(screenWidthDm = 40)) + assertEquals(2, outputs.size) + assertEquals(0, outputs.last().shows) + assertEquals(1, outputs.last().closes) + assertFalse(subscriptions.contains(true)) + } + + @Test fun closeFailureStillReleasesObserverAndDoesNotBlockTheNextResume() { + menus.resume(owner) + outputs.single().closeError = IllegalStateException("already destroyed surface") + menus.pause(owner) + assertFalse(subscriptions.last()) + menus.resume(owner) + assertEquals(2, outputs.size) + assertEquals(1, outputs.last().shows) + } + + @Test fun unexpectedDismissalGetsOneScheduledRetryAndStopsAfterASecondFailure() { + menus.resume(owner) + val old = outputs.single() + old.fail(GlassesMenuDisplayStopped()) + assertEquals(1, old.closes) + assertFalse(subscriptions.last()) + assertEquals(1, scheduled.size) + assertEquals(1, outputs.size) + + scheduled.removeFirst().invoke() + assertEquals(2, outputs.size) + assertTrue(subscriptions.last()) + outputs.last().fail(GlassesMenuDisplayStopped()) + assertTrue(scheduled.isEmpty()) + assertFalse(subscriptions.last()) + menus.update(glasses, saved) + assertEquals(2, outputs.size) + + menus.update(glasses, saved.copy(screenWidthDm = 40)) + assertEquals(3, outputs.size) + outputs.last().fail(GlassesMenuDisplayStopped()) + assertEquals(1, scheduled.size) + } + + @Test fun scheduledDismissalRecoveryCannotReopenAfterPauseOrReplaceANewerOutput() { + menus.resume(owner) + outputs.single().fail(GlassesMenuDisplayStopped()) + menus.pause(owner) + scheduled.removeFirst().invoke() + assertEquals(1, outputs.size) + assertFalse(subscriptions.last()) + + menus.resume(owner) + outputs.last().fail(GlassesMenuDisplayStopped()) + menus.pause(owner) + menus.resume(owner) + val replacement = outputs.last() + scheduled.removeFirst().invoke() + assertEquals(3, outputs.size) + assertEquals(0, replacement.closes) + assertTrue(subscriptions.last()) + } + + @Test fun displayResizeAllowsRetryAfterARealRendererFailureWithoutRetryingEveryStateUpdate() { + menus.resume(owner) + outputs.single().fail(IllegalStateException("old surface size")) + assertTrue(scheduled.isEmpty()) + menus.update(glasses.copy(tracking = true), saved) + assertEquals(1, outputs.size) + menus.update(glasses.copy(width = 3840, sbs = true), saved) + assertEquals(2, outputs.size) + assertEquals(3840, outputs.last().state!!.width) + assertTrue(subscriptions.last()) + } + + private fun addDisplay(): Display { + val id = ShadowDisplayManager.addDisplay("w1920dp-h1080dp") + displays += id + return RuntimeEnvironment.getApplication().getSystemService(DisplayManager::class.java).getDisplay(id) + } + + private class FakeOutput(val owner: Activity, val display: Display, val fail: (Throwable) -> Unit) : GlassesMenuController.Output { + var configurations = 0 + var shows = 0 + var closes = 0 + var state: GlassesState? = null + var settings: GlassesSettings? = null + var onConfigure: () -> Unit = {} + var showError: RuntimeException? = null + var closeError: RuntimeException? = null + override fun configure(state: GlassesState, settings: GlassesSettings) { + configurations++ + this.state = state + this.settings = settings + onConfigure() + } + override fun show() { shows++; showError?.let { throw it } } + override fun close() { closes++; closeError?.let { throw it } } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuPoseTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuPoseTest.kt new file mode 100644 index 0000000000..9314160aa9 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuPoseTest.kt @@ -0,0 +1,142 @@ +package com.droiddeck.launcher.glasses + +import com.droiddeck.launcher.gpu.HeadPose +import org.junit.Assert.assertArrayEquals +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class GlassesMenuPoseTest { + private val time = 1_000_000_000L + + @Test fun firstFreshGlassesPoseCentersTheScreenInAllThreeAxes() { + val pose = GlassesMenuPose(spatialEnabled = { false }) + pose.onPose(0.2f, -0.3f, 0.1f, 0.9f, time) + + val frame = pose.snapshot(time) + + assertTrue(frame.valid) + assertArrayEquals(HeadPose.IDENTITY, frame.rotation, 1e-5f) + assertArrayEquals(FloatArray(3), frame.position, 0f) + } + + @Test fun pageConfigurationPreservesTheThreeDofAnchorUntilExplicitRecenter() { + val pose = GlassesMenuPose(spatialEnabled = { false }) + pose.onPose(0f, 0f, 0f, 1f, time) + pose.snapshot(time) + pose.onPose(0f, 0f, 0.1f, 0.995f, time+1) + val moved = pose.snapshot(time+1) + + pose.configure(GlassesSettings(screenWidthDm = 40)) + assertArrayEquals(moved.rotation, pose.snapshot(time+2).rotation, 0f) + assertTrue(moved.rotation.zip(HeadPose.IDENTITY.toList()).any { (a, b) -> kotlin.math.abs(a-b) > 0.1f }) + + pose.recenter() + assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+3).rotation, 1e-5f) + } + + @Test fun invalidOldAndFutureSamplesCannotReplaceTheLastSafeView() { + val pose = GlassesMenuPose(spatialEnabled = { false }) + pose.onPose(0f, 0f, 0f, 1f, time) + pose.snapshot(time) + pose.onPose(0f, 0.1f, 0f, 0.995f, time+1) + val valid = pose.snapshot(time+1) + pose.onPose(Float.NaN, 0f, 0f, 1f, time+2) + pose.onPose(0f, 0f, 0f, 0f, time+3) + pose.onPose(0.1f, 0f, 0f, 0.995f, time) + + val stale = pose.snapshot(time+GlassesMenuPose.MAX_AGE_NS+2) + assertFalse(stale.valid) + assertArrayEquals(valid.rotation, stale.rotation, 0f) + pose.onPose(0.1f, 0f, 0f, 0.995f, time+1_000_000_000L) + val future = pose.snapshot(time+20) + assertFalse(future.valid) + assertArrayEquals(valid.rotation, future.rotation, 0f) + } + + @Test fun detachResetDiscardsOldOriginAndHeldPose() { + val pose = GlassesMenuPose(spatialEnabled = { false }) + pose.onPose(0f, 0f, 0f, 1f, time) + pose.snapshot(time) + pose.onPose(0f, 0.2f, 0f, 0.98f, time+1) + pose.snapshot(time+1) + + pose.reset() + assertFalse(pose.snapshot(time+2).valid) + assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+2).rotation, 0f) + pose.onPose(0.2f, 0f, 0f, 0.98f, time+3) + assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+3).rotation, 1e-5f) + } + + @Test fun spatialScreenPoseKeepsMetresAndHoldsDuringTrackingLoss() { + var current: SpatialPose? = SpatialPose(SpatialVector(0.2f, -0.1f, 0.3f), SpatialRotation(y = 0.1f, w = 0.995f)) + var recenters = 0 + val pose = GlassesMenuPose({ true }, { current }, { recenters++ }) + pose.configure(GlassesSettings(positionalTracking = true)) + val valid = pose.snapshot(time) + + assertTrue(valid.spatial) + assertTrue(valid.valid) + assertArrayEquals(floatArrayOf(0.2f, -0.1f, 0.3f), valid.position, 0f) + current = null + val lost = pose.snapshot(time+1) + assertFalse(lost.valid) + assertArrayEquals(valid.position, lost.position, 0f) + assertArrayEquals(valid.rotation, lost.rotation, 0f) + pose.recenter() + assertEquals(1, recenters) + } + + @Test fun disabledTrackingReturnsAnUntranslatedCenteredView() { + val pose = GlassesMenuPose({ true }, { SpatialPose(SpatialVector(x = 0.2f)) }, {}) + pose.configure(GlassesSettings(positionalTracking = true)) + pose.snapshot(time) + + pose.configure(GlassesSettings(headTracking = false, positionalTracking = true)) + + val frame = pose.snapshot(time+1) + assertFalse(frame.valid) + assertArrayEquals(HeadPose.IDENTITY, frame.rotation, 0f) + assertArrayEquals(FloatArray(3), frame.position, 0f) + } + + @Test fun menuRecenterChangesTheScreenOriginWithoutMovingTheVrFloorOrigin() { + val session = SpatialSession() + session.reset(1, 1.6f) + session.accept(SpatialSample(SpatialPose(SpatialVector(1f, 2f, 3f)), time, 1, true)) + session.accept(SpatialSample(SpatialPose(SpatialVector(1.2f, 2.1f, 3f)), time+1, 1, true)) + val pose = GlassesMenuPose({ true }, { now -> session.view(true).takeIf { session.valid(now) } }, + { session.recenter(true, time+1) }) + pose.configure(GlassesSettings(positionalTracking = true)) + val vrBefore = session.view(false)!! + assertArrayEquals(floatArrayOf(0.2f, 0.1f, 0f), pose.snapshot(time+1).position, 1e-5f) + + pose.recenter() + + assertArrayEquals(FloatArray(3), pose.snapshot(time+1).position, 1e-5f) + assertEquals(vrBefore, session.view(false)) + } + + @Test fun malformedSpatialPoseCannotReplaceTheHeldView() { + var current = SpatialPose(SpatialVector(x = 0.1f)) + val pose = GlassesMenuPose({ true }, { current }, {}) + pose.configure(GlassesSettings(positionalTracking = true)) + val valid = pose.snapshot(time) + + current = SpatialPose(SpatialVector(x = Float.NaN)) + assertFalse(pose.snapshot(time+1).valid) + assertArrayEquals(valid.position, pose.snapshot(time+1).position, 0f) + current = SpatialPose(rotation = SpatialRotation(w = 0f)) + assertFalse(pose.snapshot(time+2).valid) + assertArrayEquals(valid.rotation, pose.snapshot(time+2).rotation, 0f) + } + + @Test fun snapshotsDoNotExposeTheHeldArraysForMutation() { + val pose = GlassesMenuPose(spatialEnabled = { false }) + pose.onPose(0f, 0f, 0f, 1f, time) + pose.snapshot(time).rotation.fill(Float.NaN) + + assertArrayEquals(HeadPose.IDENTITY, pose.snapshot(time+GlassesMenuPose.MAX_AGE_NS+1).rotation, 1e-5f) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuProjectionTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuProjectionTest.kt new file mode 100644 index 0000000000..d1cd22769a --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesMenuProjectionTest.kt @@ -0,0 +1,82 @@ +package com.droiddeck.launcher.glasses + +import com.droiddeck.launcher.gpu.HeadPose +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNotNull +import org.junit.Assert.assertNull +import org.junit.Test + +class GlassesMenuProjectionTest { + private fun frame(rotation: FloatArray = HeadPose.IDENTITY, position: FloatArray = FloatArray(3)) = + GlassesMenuPose.Frame(rotation, position, true, false) + + private fun hit(pose: GlassesMenuPose.Frame = frame(), x: Float = 0f, y: Float = 0f, eye: Float = 0f, + aspect: Float = 2f) = GlassesMenuProjection.intersect(pose, x, y, eye, 1f, 3f, aspect) + + @Test fun centeredForwardRaySamplesTheTextureCenter() { + assertEquals(GlassesMenuProjection.Uv(0.5f, 0.5f), hit()) + } + + @Test fun screenTopAndRightRaysUseTopLeftTextureCoordinates() { + val topRight = hit(x = 1f/3f, y = -1f/6f)!! + assertEquals(1f, topRight.x, 1e-5f) + assertEquals(0f, topRight.y, 1e-5f) + } + + @Test fun eyeOriginsShiftByPhysicalIpdWhileMonoUsesTheCenter() { + val left = hit(eye = -GlassesMenuSurface.IPD_METERS/2)!! + val right = hit(eye = GlassesMenuSurface.IPD_METERS/2)!! + assertEquals(0.484f, left.x, 1e-5f) + assertEquals(0.516f, right.x, 1e-5f) + assertEquals(0.5f, hit()!!.x, 0f) + } + + @Test fun translatedHeadUsesMetresInTheAnchoredScreenFrame() { + val translated = hit(frame(position = floatArrayOf(0.2f, 0.1f, 0f)))!! + assertEquals(0.6f, translated.x, 1e-5f) + assertEquals(0.4f, translated.y, 1e-5f) + } + + @Test fun rowMajorPositiveYawTurnsTheForwardRayTowardNegativeX() { + val angle = Math.toRadians(10.0) + val rotation = SpatialRotation(y = kotlin.math.sin(angle/2).toFloat(), w = kotlin.math.cos(angle/2).toFloat()).matrix() + assertEquals(0.5f - 1.5f*kotlin.math.tan(angle).toFloat(), hit(frame(rotation))!!.x, 1e-5f) + } + + @Test fun aRayBehindTheHeadOrOutsideThePlaneHasNoUiHit() { + assertNull(hit(frame(rotation = SpatialRotation(y = 1f, w = 0f).matrix()))) + assertNull(hit(x = 1f)) + assertNull(hit(frame(position = floatArrayOf(0f, 0f, -4f)))) + } + + @Test fun sourceAspectChangesThePlaneHeightWithoutStretchingItsWidth() { + assertNotNull(hit(y = 0.2f, aspect = 1f)) + assertNull(hit(y = 0.2f, aspect = 2f)) + } + + @Test fun nonFiniteInputsCannotCreateTextureCoordinates() { + assertNull(hit(x = Float.NaN)) + assertNull(hit(frame(position = floatArrayOf(Float.POSITIVE_INFINITY, 0f, 0f)))) + } +} + +private object GlassesMenuProjection { + data class Uv(val x: Float, val y: Float) + + // Row-major head-to-anchor rotation; +Y is up, -Z is forward, output UV starts at the top left. + fun intersect(frame: GlassesMenuPose.Frame, rayX: Float, rayY: Float, eye: Float, + halfWidth: Float, distance: Float, aspect: Float): Uv? { + if (frame.rotation.size != 9 || frame.position.size != 3 || frame.rotation.any { !it.isFinite() } || + frame.position.any { !it.isFinite() } || listOf(rayX, rayY, eye, halfWidth, distance, aspect).any { !it.isFinite() } || + halfWidth <= 0f || distance <= 0f || aspect <= 0f) return null + val r = frame.rotation + val d = FloatArray(3) { row -> r[row*3]*rayX - r[row*3+1]*rayY - r[row*3+2] } + val o = FloatArray(3) { row -> frame.position[row] + r[row*3]*eye } + if (d[2] >= -0.0001f) return null + val t = (-distance-o[2]) / d[2] + if (t <= 0f) return null + val u = (o[0]+d[0]*t) / halfWidth * 0.5f + 0.5f + val v = -(o[1]+d[1]*t) * aspect / halfWidth * 0.5f + 0.5f + return Uv(u, v).takeIf { u in 0f..1f && v in 0f..1f } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt index 993a1799af..401d247013 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesRenderingTest.kt @@ -11,6 +11,25 @@ class GlassesRenderingTest { ) private val base = Cardboard(ipdMm = 67) + @Test fun thirtyHzRequiresANativeModeAndDedicatedGlassesOutput() { + val settings = GlassesSettings(refreshHz = 30, sbsHz = 30) + for (stereo in listOf(false, true)) for (sbs90 in listOf(false, true)) { + val state = ultra.copy(sbs = stereo, sbs90 = sbs90, supports30Hz = true) + assertTrue(GlassesRendering.refreshRates(settings, state).contains(30)) + assertEquals(30, GlassesRendering.outputHz(settings, state)) + assertEquals(60, GlassesRendering.mirrorRefreshLimit(settings, state.copy(hz = 60f), false)) + assertEquals(30, GlassesRendering.mirrorRefreshLimit(settings, state.copy(hz = 29.97f), false)) + for (unavailable in listOf(state.copy(supports30Hz = false), state.copy(noSignal = true), state.copy(displayId = -1))) { + assertFalse(GlassesRendering.refreshRates(settings, unavailable).contains(30)) + assertEquals(60, GlassesRendering.outputHz(settings, unavailable)) + } + val mirrored = settings.copy(gameOnGlasses = false) + assertFalse(GlassesRendering.refreshRates(mirrored, state).contains(30)) + assertEquals(60, GlassesRendering.outputHz(mirrored, state)) + assertEquals(60, GlassesRendering.mirrorRefreshLimit(mirrored, state, false)) + } + } + @Test fun mirroredRefreshUsesTheSelectedGlassesRateEvenBeforeTheDisplaySwitches() { val settings = GlassesSettings(gameOnGlasses = false, refreshHz = 60) assertEquals(60, GlassesRendering.mirrorRefreshLimit(settings, ultra.copy(hz = 120f), false)) @@ -75,27 +94,82 @@ class GlassesRenderingTest { assertFalse(changed.headTracking) } - @Test fun automatic3dGamesUseAVirtualScreenButSteamVrUsesDirectStereo() { + @Test fun automaticSbsDuplicatesTheWholeFrameWithoutEnablingHeadTracking() { val settings = GlassesSettings() val stereo = ultra.copy(sbs = true, width = 3840) - assertEquals(GlassesRendering.Picture.VIRTUAL_SCREEN, GlassesRendering.picture(settings, true, false)) - assertEquals(Cardboard.SOURCE_SCREEN, render(settings, stereo).source) + assertEquals(GlassesRendering.Picture.DUPLICATED, GlassesRendering.picture(settings, true, false)) + assertEquals(Cardboard.SOURCE_FLAT, render(settings, stereo).source) + assertFalse(render(settings, stereo).headTracking) assertFalse(render(settings, stereo).mono) assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(settings, true, true)) assertEquals(Cardboard.SOURCE_SBS, render(settings, stereo, steamVr = true).source) + assertTrue(render(settings, stereo, steamVr = true).headTracking) } - @Test fun explicitPictureChoiceOverridesAutomaticResolution() { + @Test fun flatSbsDoesNotDependOnTheTrackingPreferenceOrUsbControl() { + for (tracking in listOf(false, true)) for (connected in listOf(false, true)) { + for (height in listOf(1080, 1200)) { + val state = ultra.copy(sbs = true, width = 3840, height = height, connected = connected) + val settings = GlassesSettings(headTracking = tracking) + val flat = render(settings, state) + assertTrue(flat.enabled) + assertFalse(flat.mono) + assertFalse(flat.headTracking) + assertEquals(Cardboard.SOURCE_FLAT, flat.source) + assertEquals(Cardboard.SOURCE_SBS, render(settings.copy(picture3d = GlassesSettings.PICTURE_SBS), state).source) + } + } + } + + @Test fun virtualScreenTracksFlatContentIndependentlyOfTheHardwareSbsMode() { + val settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN) + assertTrue(settings.screen3dof) + assertFalse(settings.copy(headTracking = false).screen3dof) + for (height in listOf(1080, 1200)) { + for (sbs in listOf(false, true)) { + val projection = render(settings, ultra.copy(width = if (sbs) 3840 else 1920, height = height, sbs = sbs)) + assertTrue(projection.enabled) + assertTrue(projection.headTracking) + assertEquals(Cardboard.SOURCE_SCREEN, projection.source) + assertEquals(!sbs, projection.mono) + } + } + } + + @Test fun explicitPictureChoiceOverridesAutomaticResolutionOutsideSteamVr() { val virtual = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN) val direct = GlassesSettings(picture3d = GlassesSettings.PICTURE_SBS) for (stereo in listOf(false, true)) { - for (vr in listOf(false, true)) { - assertEquals(GlassesRendering.Picture.VIRTUAL_SCREEN, GlassesRendering.picture(virtual, stereo, vr)) - assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(direct, stereo, vr)) + assertEquals(GlassesRendering.Picture.VIRTUAL_SCREEN, GlassesRendering.picture(virtual, stereo, false)) + assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(direct, stereo, false)) + } + } + + @Test fun steamVrSplitsTheEyePairRegardlessOfTheSavedFlatGamePicture() { + for (picture in listOf(GlassesSettings.PICTURE_AUTO, GlassesSettings.PICTURE_SCREEN, GlassesSettings.PICTURE_SBS)) { + val settings = GlassesSettings(picture3d = picture, auto3d = true) + for (stereo in listOf(false, true)) for (outputActive in listOf(false, true)) { + val state = ultra.copy(sbs = stereo, width = if (stereo) 3840 else 1920) + val projection = GlassesRendering.cardboard(base, settings, state, outputActive, true) + assertEquals(GlassesRendering.Picture.STEREO, GlassesRendering.picture(settings, stereo, true)) + assertEquals(Cardboard.SOURCE_SBS, projection.source) + assertEquals(!stereo, projection.mono) + assertTrue(projection.enabled) + assertTrue(projection.headTracking) } } } + @Test fun stoppingSteamVrRestoresTheSavedVirtualScreen() { + val settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, auto3d = true, + screenWidthDm = 18, screenDistanceDm = 30) + val before = render(settings) + assertEquals(Cardboard.SOURCE_SCREEN, before.source) + assertEquals(Cardboard.SOURCE_SBS, render(settings, steamVr = true).source) + assertEquals(before, render(settings)) + assertEquals(GlassesSettings.PICTURE_SCREEN, settings.picture3d) + } + @Test fun mirrorModeKeepsThePhoneProjectionInsteadOfApplyingDormantGlassesSettings() { val phone = base.copy(enabled = true, screenWidthDm = 60, screenDistanceDm = 20) val settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesScreenTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesScreenTest.kt index f092b8413f..6d1ecb1c2e 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesScreenTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesScreenTest.kt @@ -4,6 +4,8 @@ import android.hardware.display.DisplayManager import android.view.Display import android.view.SurfaceHolder import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue import org.junit.Test import org.junit.runner.RunWith import org.robolectric.RobolectricTestRunner @@ -21,6 +23,40 @@ import org.robolectric.shadows.ShadowDisplayManager @Config(sdk = [31, 34], manifest = Config.NONE, shadows = [GlassesScreenTest.ModeDisplay::class]) @LooperMode(LooperMode.Mode.PAUSED) class GlassesScreenTest { + @Test fun recoveryCoversTheExistingRenderSurfaceWithoutReplacingIt() { + val flat=mode(1,1920,1200,60f) + val (screen,_)=screen(flat,arrayOf(flat),60) + val holder=screen.holder + val root=screen.surfaceView.parent as android.view.ViewGroup + assertTrue(root.indexOfChild(screen.trackingRecovery)>root.indexOfChild(screen.surfaceView)) + screen.trackingRecovery.update(TrackingRecovery.LOST,false) + assertEquals(android.view.View.VISIBLE,screen.trackingRecovery.visibility) + screen.trackingRecovery.update(null,false) + assertEquals(android.view.View.GONE,screen.trackingRecovery.visibility) + assertTrue(holder===screen.holder) + } + + @Test fun nativeThirtyHzMustMatchBothDimensionsOfTheCurrentEyeLayout() { + val flat60 = mode(1, 1920, 1200, 60f) + val flat30 = mode(2, 1920, 1200, 29.97f) + val stereo60 = mode(3, 3840, 1200, 60f) + val stereo30 = mode(4, 3840, 1200, 30f) + val short30 = mode(5, 3840, 1080, 30f) + val (screen, panel) = screen(flat60, arrayOf(flat60, flat30, stereo60, short30), 30) + assertTrue(Glasses.supports30Hz(screen.display)) + assertEquals(flat30.modeId, screen.window!!.attributes.preferredDisplayModeId) + + panel.current = stereo60 + screen.prefer(30) + assertFalse(Glasses.supports30Hz(screen.display)) + assertEquals(stereo60.modeId, screen.window!!.attributes.preferredDisplayModeId) + + panel.supported += stereo30 + screen.prefer(30) + assertTrue(Glasses.supports30Hz(screen.display)) + assertEquals(stereo30.modeId, screen.window!!.attributes.preferredDisplayModeId) + } + @Test fun switchingBetween2dAndStereoRefreshesTheModePreferenceEvenAtTheSameHz() { val flat = mode(1, 1920, 1200, 60f) val stereo = mode(2, 3840, 1200, 60f) @@ -54,6 +90,30 @@ class GlassesScreenTest { assertEquals(stereo90.modeId, screen.window!!.attributes.preferredDisplayModeId) } + @Test fun explicitResolutionChangesBothDimensionsWithoutSwitchingEyeLayout() { + val flat1080 = mode(1, 1920, 1080, 90f) + val flat1200 = mode(2, 1920, 1200, 90f) + val stereo1080 = mode(3, 3840, 1080, 90f) + val stereo1200 = mode(4, 3840, 1200, 90f) + val (screen, panel) = screen(flat1200, arrayOf(flat1080, flat1200, stereo1080, stereo1200), 90) + screen.prefer(90, GlassesResolution(1920, 1080)) + assertEquals(flat1080.modeId, screen.window!!.attributes.preferredDisplayModeId) + panel.current = stereo1200 + screen.prefer(90, GlassesResolution(1920, 1080)) + assertEquals(stereo1080.modeId, screen.window!!.attributes.preferredDisplayModeId) + screen.prefer(90, GlassesResolution(1920, 1200)) + assertEquals(stereo1200.modeId, screen.window!!.attributes.preferredDisplayModeId) + } + + @Test fun unavailableResolutionKeepsTheCurrentModeUntilHardwareConfirmsTheChange() { + val stereo60 = mode(1, 3840, 1200, 60f) + val stereo90 = mode(2, 3840, 1200, 90f) + val flat1080 = mode(3, 1920, 1080, 90f) + val (screen, _) = screen(stereo60, arrayOf(stereo60, stereo90, flat1080), 60) + screen.prefer(90, GlassesResolution(1920, 1080)) + assertEquals(stereo90.modeId, screen.window!!.attributes.preferredDisplayModeId) + } + private fun mode(id: Int, width: Int, height: Int, hz: Float): Display.Mode = ShadowDisplayManager.ModeBuilder.modeBuilder(id) .setWidth(width).setHeight(height).setRefreshRate(hz).build() diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSessionModesTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSessionModesTest.kt new file mode 100644 index 0000000000..efea733362 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSessionModesTest.kt @@ -0,0 +1,152 @@ +package com.droiddeck.launcher.glasses + +import android.app.Application +import android.content.Intent +import android.hardware.display.DisplayManager +import android.view.Display +import androidx.compose.runtime.MutableState +import com.droiddeck.launcher.SessionActivity +import com.droiddeck.launcher.gpu.Cardboard +import com.droiddeck.launcher.gpu.SteamVr +import com.droiddeck.launcher.runtime.FlatpakManager +import com.droiddeck.launcher.session.LoadingState +import com.droiddeck.launcher.session.SessionService +import com.droiddeck.launcher.session.SessionState +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode +import org.robolectric.shadows.ShadowDisplayManager +import org.robolectric.util.ReflectionHelpers +import org.robolectric.util.ReflectionHelpers.ClassParameter + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], application = Application::class, manifest = Config.NONE) +@LooperMode(LooperMode.Mode.PAUSED) +class GlassesSessionModesTest { + private data class Launch(val name: String, val mode: String, val program: String? = null, val args: Array? = null) + private val launches = listOf( + Launch("Steam and store games", SessionService.MODE_STEAM), + Launch("Desktop", SessionService.MODE_DESKTOP), + Launch("Standalone", SessionService.MODE_RUN, "/usr/bin/example-game"), + Launch("Emulator", SessionService.MODE_RUN, "/usr/bin/retroarch", arrayOf("/games/example.rom")), + Launch("Flatpak", SessionService.MODE_RUN, FlatpakManager.LAUNCHER, arrayOf("org.example.Game")), + ) + private lateinit var display: Display + private lateinit var restore: () -> Unit + private val saved = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, + headTracking = true, screenWidthDm = 35, screenDistanceDm = 45) + private val phone = Cardboard(enabled = true, source = Cardboard.SOURCE_SCREEN, ipdMm = 67, + screenWidthDm = 20, screenDistanceDm = 30, headTracking = false) + + @Before fun setUp() { + val running = SessionState.running + val steamVr = SessionState.steamVr + val mode = SessionState.mode + val fields = listOf("context", "publisherAttached").associateWith { + SpatialTracking::class.java.getDeclaredField(it).apply { isAccessible = true } + } + val values = fields.mapValues { it.value.get(null) } + fields.getValue("context").set(null, null) + fields.getValue("publisherAttached").set(null, false) + restore = { + fields.forEach { (name, field) -> field.set(null, values[name]) } + SessionState.running = running + SessionState.steamVr = steamVr + SessionState.mode = mode + } + val id = ShadowDisplayManager.addDisplay("w1920dp-h1080dp") + display = RuntimeEnvironment.getApplication().getSystemService(DisplayManager::class.java).getDisplay(id) + SessionState.running = true + SessionState.steamVr = false + } + + @After fun tearDown() { + SpatialTracking.useLegacyTracking() + SpatialTracking.disconnect() + ShadowDisplayManager.removeDisplay(display.displayId) + restore() + } + + @Test fun flatScreenSizeDistanceAndTrackingReachEveryGuestSessionWithoutSteamVr() { + for (launch in launches) for (spatial in listOf(false, true)) { + val activity = activity(launch, saved.copy(positionalTracking = spatial), output = true) + SpatialTracking.connect(0, 101, null, spatial, 1.6f, false) + val projection = projection(activity) + + assertTrue(launch.name, projection.enabled) + assertTrue(launch.name, projection.headTracking) + assertTrue(launch.name, projection.mono) + assertEquals(launch.name, Cardboard.SOURCE_SCREEN, projection.source) + assertEquals(launch.name, Cardboard.Viewer.VITURE.id, projection.viewer) + assertEquals(launch.name, 35, projection.screenWidthDm) + assertEquals(launch.name, 45, projection.screenDistanceDm) + assertEquals(launch.name, phone.ipdMm, projection.ipdMm) + assertEquals(launch.name, if (spatial) TrackingRecovery.LOST else null, recovery(activity)) + } + } + + @Test fun positionalRecoverySurvivesUsbLossInEveryGuestSessionAndHonorsTrackingOff() { + for (launch in launches) { + val activity = activity(launch, saved.copy(positionalTracking = true), output = true) + SpatialTracking.connect(0, 102, null, true, 1.6f, false) + assertEquals(launch.name, TrackingRecovery.LOST, recovery(activity)) + + SpatialTracking.disconnect() + state(activity, "glasses", glasses().copy(connected = false, supportsSpatial = false)) + assertEquals(launch.name, TrackingRecovery.DISCONNECTED, recovery(activity)) + + state(activity, "glassesSettings", saved.copy(positionalTracking = true, headTracking = false)) + assertFalse(launch.name, projection(activity).headTracking) + assertNull(launch.name, recovery(activity)) + } + } + + @Test fun savedGlassesTrackingDoesNotChangePhoneRenderingOrRecoveryInAnySessionMode() { + for (launch in launches) { + val activity = activity(launch, saved.copy(positionalTracking = true), output = false) + SpatialTracking.connect(0, 103, null, true, 1.6f, false) + + assertSame(launch.name, phone, projection(activity)) + assertNull(launch.name, recovery(activity)) + } + } + + private fun activity(launch: Launch, settings: GlassesSettings, output: Boolean): SessionActivity { + val intent = Intent(RuntimeEnvironment.getApplication(), SessionActivity::class.java) + .putExtra(SessionService.EXTRA_MODE, launch.mode) + .putExtra(SessionService.EXTRA_PROGRAM, launch.program) + .putExtra(SessionService.EXTRA_PROGRAM_ARGS, launch.args) + SessionState.mode = launch.mode + return Robolectric.buildActivity(SessionActivity::class.java, intent).get().also { + ReflectionHelpers.setField(it, "loading", LoadingState(it).apply { visible = false }) + ReflectionHelpers.setField(it, "started", true) + if (output) ReflectionHelpers.setField(it, "glassesScreen", GlassesScreen(it, display, 60, it)) + state(it, "glassesOutputActive", output) + state(it, "glasses", glasses()) + state(it, "glassesSettings", settings) + state(it, "steamVrStatus", SteamVr.Status.READY) + } + } + + private fun glasses() = GlassesState(present = true, connected = true, controllable = true, + supportsSpatial = true, supportsScreen3dof = true, displayId = display.displayId, width = 1920, height = 1080) + + private fun projection(activity: SessionActivity): Cardboard = ReflectionHelpers.callInstanceMethod( + activity, "effectiveCardboard", ClassParameter.from(Cardboard::class.java, phone)) + + private fun recovery(activity: SessionActivity): TrackingRecovery? { + ReflectionHelpers.callInstanceMethod(activity, "updateTrackingRecovery") + return ReflectionHelpers.getField>(activity, "trackingRecovery\$delegate").value + } + + private fun state(activity: SessionActivity, name: String, value: T) { + ReflectionHelpers.getField>(activity, name + "\$delegate").value = value + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSpatialAvailabilityTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSpatialAvailabilityTest.kt new file mode 100644 index 0000000000..58efe3aa0a --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSpatialAvailabilityTest.kt @@ -0,0 +1,33 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class GlassesSpatialAvailabilityTest { + private val ultra = GlassesState(connected = true, controllable = true, supportsSpatial = true) + private val selected = GlassesSettings(positionalTracking = true, handControllers = true) + + @Test fun sdkConfirmedConnectedUltraOwnsSpatialControllerInput() { + assertTrue(ultra.spatialConnected) + assertTrue(ultra.usesSpatialControllers(selected)) + assertTrue(ultra.usesSpatialControllers(selected.copy(handControllers = false, joyConTracking = true))) + assertFalse(ultra.usesSpatialControllers(selected.copy(positionalTracking = false))) + assertFalse(ultra.usesSpatialControllers(selected.copy(handControllers = false))) + } + + @Test fun savedUltraPreferencesDoNotSelectSpatialInputForOtherGlasses() { + for (name in listOf("VITURE Luma Ultra", "VITURE Luma Pro", "VITURE Pro", "XREAL", "RayNeo")) { + val other = ultra.copy(model = name, supportsSpatial = false) + assertFalse(name, other.spatialConnected) + assertFalse(name, other.usesSpatialControllers(selected)) + assertFalse(name, other.usesSpatialControllers(selected.copy(handControllers = false, joyConTracking = true))) + } + } + + @Test fun disconnectedOrUncontrollableUltraCannotClaimSpatialInput() { + for (state in listOf(ultra.copy(connected = false), ultra.copy(controllable = false), GlassesState())) { + assertFalse(state.spatialConnected) + assertFalse(state.usesSpatialControllers(selected)) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSteamVrTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSteamVrTest.kt index 471aa804d2..02ab5aca8d 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSteamVrTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesSteamVrTest.kt @@ -4,6 +4,7 @@ import android.app.Application import android.content.Context import android.os.Handler import android.os.Looper +import android.os.SystemClock import com.droiddeck.launcher.SessionActivity import com.droiddeck.launcher.gpu.SteamVr import com.droiddeck.launcher.session.LoadingState @@ -24,6 +25,7 @@ import org.robolectric.annotation.LooperMode import java.util.concurrent.CountDownLatch import java.util.concurrent.ThreadPoolExecutor import java.util.concurrent.TimeUnit +import java.time.Duration @RunWith(RobolectricTestRunner::class) @Config(sdk = [28], application = Application::class) @@ -33,8 +35,10 @@ class GlassesSteamVrTest { private val handler = Handler(Looper.getMainLooper()) private lateinit var restore: () -> Unit private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true } + private val spatialGate get() = field("steamVrSpatialGate").get(null) as SteamVrSpatialGate @Before fun prepare() { + spatialGate.cancel() val fields = listOf("handler", "app", "model").associateWith { field(it).get(null) } @Suppress("UNCHECKED_CAST") val flows = listOf("_state", "_settings").map { field(it).get(null) as MutableStateFlow } @@ -64,6 +68,7 @@ class GlassesSteamVrTest { @After fun cleanUp() { handler.removeCallbacksAndMessages(null) + spatialGate.cancel() field("link").set(null, null) (field("modeState").get(null) as GlassesModeState).apply { manual(); sent(false, 0) } SessionState.steamVr = false @@ -133,6 +138,7 @@ class GlassesSteamVrTest { .apply { isAccessible = true }.invoke(activity, name) action("start") assertTrue("A manual start must keep status polling alive", SessionState.steamVr) + shadowOf(Looper.getMainLooper()).idle() val worker = SessionActivity::class.java.getDeclaredField("steamVrWorker") .apply { isAccessible = true }.get(null) as ThreadPoolExecutor assertEquals(1, worker.queue.size) @@ -146,6 +152,90 @@ class GlassesSteamVrTest { } } + @Test fun preparationCallbackRunsAfterSuspensionAndCancelWorksBeforeRunning() { + @Suppress("UNCHECKED_CAST") + val settings = field("_settings").get(null) as MutableStateFlow + settings.value = GlassesSettings(positionalTracking = true, handControllers = true) + val saved = settings.value + var prepared = 0 + repeat(2) { + Glasses.prepareSteamVrStart { + assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + prepared++ + } + } + shadowOf(Looper.getMainLooper()).idle() + assertEquals(2, prepared) + Glasses.setVrActive(false) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(3)) + assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + Glasses.cancelSteamVrStart() + shadowOf(Looper.getMainLooper()).idle() + assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + assertEquals(saved, settings.value) + } + + @Test fun rapidRestartDoesNotLaunchTheCancelledPreparedRequest() = withLaunch(auto3d = false) { activity -> + SessionState.steamVr = false + val action = SessionActivity::class.java.getDeclaredMethod("steamVrAction", String::class.java) + .apply { isAccessible = true } + action.invoke(activity, "start") + action.invoke(activity, "stop") + action.invoke(activity, "start") + shadowOf(Looper.getMainLooper()).idle() + val worker = SessionActivity::class.java.getDeclaredField("steamVrWorker") + .apply { isAccessible = true }.get(null) as ThreadPoolExecutor + assertTrue(SessionState.steamVr) + assertEquals("Only stop and the latest start should reach the worker", 2, worker.queue.size) + } + + @Test fun duplicateRunningKeepsDeadlineAndStoppingCancelsThePendingResume() { + Glasses.prepareSteamVrStart() + Glasses.setVrActive(true) + shadowOf(Looper.getMainLooper()).idle() + val deadline = spatialGate.deadline!! + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1_999)) + var prepared = false + Glasses.prepareSteamVrStart { prepared = true } + Glasses.setVrActive(true) + shadowOf(Looper.getMainLooper()).idle() + assertTrue(prepared) + assertEquals(deadline, spatialGate.deadline) + assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1)) + assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + Glasses.setVrActive(false) + Glasses.prepareSteamVrStart() + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(3)) + assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + assertNull(spatialGate.deadline) + } + + @Test fun restartWhileDisplayStillReportsRunningGetsANewTrackingDeadline() { + Glasses.setVrActive(true) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofSeconds(3)) + assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + Glasses.cancelSteamVrStart() + Glasses.prepareSteamVrStart() + shadowOf(Looper.getMainLooper()).idle() + assertTrue(Glasses.state.value.vrActive) + assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + Glasses.setVrActive(true) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1_999)) + assertFalse(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + shadowOf(Looper.getMainLooper()).idleFor(Duration.ofMillis(1)) + assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + } + + @Test fun endedSessionIgnoresLateRunningStatus() = withLaunch(auto3d = true) { activity -> + SessionActivity::class.java.getDeclaredField("ended").apply { isAccessible = true }.set(activity, true) + status(activity, SteamVr.Status.RUNNING) + assertFalse(Glasses.state.value.vrActive) + assertNull(spatialGate.deadline) + assertTrue(spatialGate.spatialEnabled(true, SystemClock.uptimeMillis())) + assertTrue(commands.isEmpty()) + } + private fun status(activity: SessionActivity, status: SteamVr.Status) { SessionActivity::class.java.getDeclaredMethod("onSteamVrStatus", SteamVr.Status::class.java) .apply { isAccessible = true }.invoke(activity, status) diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesTrackingRoutingTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesTrackingRoutingTest.kt new file mode 100644 index 0000000000..3409d6f83d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesTrackingRoutingTest.kt @@ -0,0 +1,192 @@ +package com.droiddeck.launcher.glasses + +import android.app.Application +import android.os.HandlerThread +import android.view.Display +import androidx.compose.runtime.MutableState +import com.droiddeck.launcher.SessionActivity +import com.droiddeck.launcher.gpu.Cardboard +import com.droiddeck.launcher.gpu.SteamVr +import com.droiddeck.launcher.input.ControllerPrefs +import com.droiddeck.launcher.input.JoyConVr +import com.droiddeck.launcher.session.LoadingState +import com.droiddeck.launcher.session.SessionState +import java.io.File +import java.nio.ByteBuffer +import java.nio.ByteOrder +import org.junit.After +import org.junit.Assert.* +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.Robolectric +import org.robolectric.RobolectricTestRunner +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode +import org.robolectric.util.ReflectionHelpers + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], application = Application::class, manifest = Config.NONE) +@LooperMode(LooperMode.Mode.PAUSED) +class GlassesTrackingRoutingTest { + private lateinit var activity: SessionActivity + private lateinit var restore: () -> Unit + private val ultra = GlassesState(present = true, connected = true, controllable = true, + supportsSpatial = true, displayId = Display.DEFAULT_DISPLAY + 1, width = 1920, height = 1080) + private val saved = GlassesSettings(positionalTracking = true, handControllers = true) + + @Before fun setUp() { + val running = SessionState.running + val steamVr = SessionState.steamVr + val fields = listOf("context", "publisherAttached").associateWith { + SpatialTracking::class.java.getDeclaredField(it).apply { isAccessible = true } + } + val values = fields.mapValues { it.value.get(null) } + fields.getValue("context").set(null, null) + fields.getValue("publisherAttached").set(null, false) + restore = { + fields.forEach { (name, field) -> field.set(null, values[name]) } + SessionState.running = running + SessionState.steamVr = steamVr + } + activity = Robolectric.buildActivity(SessionActivity::class.java).get() + ReflectionHelpers.setField(activity, "loading", LoadingState(activity).apply { visible = false }) + ReflectionHelpers.setField(activity, "started", true) + ReflectionHelpers.setField(activity, "activeCardboard", Cardboard.OFF) + state("glasses", ultra) + state("glassesSettings", saved) + state("steamVrStatus", SteamVr.Status.RUNNING) + SessionState.running = true + SessionState.steamVr = true + SpatialTracking.setOutputUsesGlasses(true) + SpatialTracking.connect(0, 81, null, true, 1.6f, true) + } + + @After fun tearDown() { + SpatialTracking.useLegacyTracking() + SpatialTracking.disconnect() + SpatialTracking.setOutputUsesGlasses(true) + restore() + } + + @Test fun usbLossKeepsSpatialOwnershipAndShowsRecoveryOnTheGlassesDisplay() { + SpatialTracking.disconnect() + state("glasses", ultra.copy(connected = false, supportsSpatial = false)) + updateRouting() + + assertEquals(3, modes()) + assertTrue(SpatialTracking.selected) + assertEquals(TrackingRecovery.DISCONNECTED, recovery()) + } + + @Test fun phoneHandoffClearsPublishedModesWithoutErasingTheGlassesSelection() { + for (joyCons in listOf(false, true)) { + val selected = saved.copy(handControllers = !joyCons, joyConTracking = joyCons) + state("glassesSettings", selected) + SpatialTracking.connect(0, if (joyCons) 83 else 82, null, true, 1.6f, !joyCons, joyCons) + SpatialTracking.disconnect() + state("glasses", GlassesState()) + updateRouting() + + assertEquals(0, modes()) + assertTrue(SpatialTracking.selected) + assertEquals(selected, stateValue("glassesSettings")) + assertNull(recovery()) + SpatialTracking.setControllers(!joyCons, joyCons) + assertEquals("Later controller updates must not reclaim the phone output", 0, modes()) + + SpatialTracking.connect(0, if (joyCons) 85 else 84, null, true, 1.6f, !joyCons, joyCons) + assertEquals("Reconnecting waits for the output handoff", 0, modes()) + state("glasses", ultra) + updateRouting() + assertEquals(if (joyCons) 5 else 3, modes()) + } + } + + @Test fun endingTheSessionReleasesSpatialInputEvenWhileTheGlassesRemainConnected() { + ReflectionHelpers.setField(activity, "ended", true) + updateRouting() + + assertEquals(0, modes()) + assertTrue(SpatialTracking.selected) + assertEquals(saved, stateValue("glassesSettings")) + assertNull(recovery()) + } + + @Test @Config(sdk = [31]) fun displayLossReleasesSpatialControllerOverridesWhileUsbRemainsConnected() { + val previousJoyConVr = ControllerPrefs.joyConVr(activity) + ControllerPrefs.setJoyConVr(activity, false) + val joyCon = JoyConVr(activity, File(activity.cacheDir, "routing-joycons")) { _, _ -> } + ReflectionHelpers.setField(activity, "joyConVr", joyCon) + val worker = ReflectionHelpers.getField(joyCon, "thread") + fun updateInputs(): Boolean { + ReflectionHelpers.callInstanceMethod(activity, "updateJoyConTracking") + shadowOf(worker.looper).idle() + return ReflectionHelpers.getField(joyCon, "wanted") + } + try { + for (joyCons in listOf(false, true)) { + val selected = saved.copy(handControllers = !joyCons, joyConTracking = joyCons) + state("glassesSettings", selected) + for (displayLost in listOf(ultra.copy(noSignal = true), ultra.copy(displayId = Display.INVALID_DISPLAY))) { + state("glasses", ultra) + assertTrue(ReflectionHelpers.callInstanceMethod(activity, "usesSpatialControllers")) + assertEquals(joyCons, updateInputs()) + + state("glasses", displayLost) + updateRouting() + assertTrue(displayLost.spatialConnected) + assertEquals(0, modes()) + assertFalse("The phone camera must not be suppressed by a missing display", + ReflectionHelpers.callInstanceMethod(activity, "usesSpatialControllers")) + assertFalse("Saved glasses Joy-Cons must not override the phone preference", updateInputs()) + assertEquals(selected, stateValue("glassesSettings")) + ControllerPrefs.setJoyConVr(activity, true) + assertTrue("The phone Joy-Con preference must still apply", updateInputs()) + ControllerPrefs.setJoyConVr(activity, false) + + state("glasses", ultra) + updateRouting() + assertTrue(ReflectionHelpers.callInstanceMethod(activity, "usesSpatialControllers")) + assertEquals(joyCons, updateInputs()) + } + } + } finally { + ReflectionHelpers.setField(activity, "joyConVr", null) + joyCon.close() + ControllerPrefs.setJoyConVr(activity, previousJoyConVr) + } + } + + @Test fun anotherGlassesModelDoesNotActivateSavedUltraTracking() { + SpatialTracking.disconnect() + SpatialTracking.useLegacyTracking() + state("glasses", ultra.copy(model = "XREAL", supportsSpatial = false)) + updateRouting() + + assertEquals(0, modes()) + assertFalse(SpatialTracking.selected) + assertEquals(saved, stateValue("glassesSettings")) + assertNull(recovery()) + } + + private fun updateRouting() { + ReflectionHelpers.callInstanceMethod(activity, "updateHeadTracker") + ReflectionHelpers.callInstanceMethod(activity, "updateTrackingRecovery") + } + + private fun modes(): Int { + val field = SpatialTracking::class.java.getDeclaredField("buffer").apply { isAccessible = true } + return (field.get(null) as ByteBuffer).duplicate().order(ByteOrder.LITTLE_ENDIAN).getInt(32) + } + + private fun recovery(): TrackingRecovery? = stateValue("trackingRecovery") + + private fun state(name: String, value: T) { + ReflectionHelpers.getField>(activity, name + "\$delegate").value = value + } + + private fun stateValue(name: String): T = + ReflectionHelpers.getField>(activity, name + "\$delegate").value +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt index d627353cb3..d4ee21f796 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/GlassesUsbTest.kt @@ -165,6 +165,36 @@ class GlassesUsbTest { assertEquals(listOf(gt), manager.requests) } + @Test fun screen3dofAvailabilityFollowsTheTrackingTransportAcrossBrands() { + val devices = listOf(device(0x1011), device(0x1019), device(0x1131), + device(0xaf50, 0x1bbb, "RayNeo Air 4 Pro"), + device(0xaf50, 0x3941, "RayNeo GT MAX"), + device(0x043e, 0x3318, "XREAL 1S")) + try { + for (device in devices) for (imu in listOf(false, true)) { + manager.devices.clear() + manager.devices[device.deviceName] = device + manager.granted.add(device.deviceName) + field("linkDevice").set(null, device) + field("link").set(null, object : GlassesLink { + override val hasImu = imu + override fun send(msgId: Int, payload: ByteArray) = true + override fun close() {} + }) + refresh() + assertTrue(state.value.canControl) + assertEquals(imu, state.value.supportsScreen3dof) + } + manager.devices.clear() + refresh() + assertFalse(state.value.supportsScreen3dof) + } finally { + field("link").set(null, null) + field("linkDevice").set(null, null) + (field("handler").get(null) as Handler).removeCallbacksAndMessages(null) + } + } + private fun refresh(ask: Boolean = false) { Glasses::class.java.getDeclaredMethod("refresh", Boolean::class.javaPrimitiveType) .apply { isAccessible = true }.invoke(Glasses, ask) diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/HandGesturesTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/HandGesturesTest.kt new file mode 100644 index 0000000000..310b2d82e3 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/HandGesturesTest.kt @@ -0,0 +1,192 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class HandGesturesTest { + private fun openHand(): MutableList { + val p=MutableList(21) { SpatialVector(z=.5f) } + p[0]=SpatialVector(0f,0f,.5f) + p[4]=SpatialVector(.07f,-.05f,.5f) + for((base,x) in listOf(5 to .035f,9 to .01f,13 to -.015f,17 to -.04f)) { + for(j in 0..3)p[base+j]=SpatialVector(x,-.06f-.025f*j,.5f) + } + return p + } + @Test fun triangulatedMetersAreTransformedIntoTheHeadWorldFrame() { + val h=HandGestures(rightHand=false).estimate(openHand(),SpatialPose(SpatialVector(1f,2f,3f)),1_000_000_000)!! + assertEquals(3.5f,h.pose.position.z,.0001f) + assertTrue(h.pose.rotation.normalized()!=null);assertFalse(h.grip);assertEquals(0f,h.trigger,.0001f) + } + @Test fun mirroredHandsUseTheSamePalmNormalAndFingerDirection() { + val left=openHand().apply { this[9]=SpatialVector(0f,-.06f,.5f) } + val right=left.map { SpatialVector(-it.x,it.y,it.z) } + val world=SpatialPose(SpatialVector(1f,2f,3f),SpatialRotation(.2f,-.3f,.1f,.9f).normalized()!!) + for(turn in listOf(SpatialRotation(),SpatialRotation(y=1f,w=0f), + SpatialRotation(.3f,.1f,-.2f,.9f).normalized()!!)) { + val hands=listOf(left,right).mapIndexed { side,points -> + HandGestures(rightHand=side==1).estimate(points.map(turn::apply),world,1_000_000_000)!! + } + for(hand in hands) { + val rotation=hand.pose.rotation + assertVector(world.rotation.apply(turn.apply(SpatialVector(z=-1f))),rotation.apply(SpatialVector(y=1f))) + assertVector(world.rotation.apply(turn.apply(SpatialVector(y=-1f))),rotation.apply(SpatialVector(z=-1f))) + val x=rotation.apply(SpatialVector(x=1f));val y=rotation.apply(SpatialVector(y=1f)) + assertVector(rotation.apply(SpatialVector(z=1f)),x.cross(y)) + } + } + } + @Test fun rightHandOrientationDoesNotChangePinchOrGrip() { + val points=openHand() + points[4]=points[8] + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) points[tip]=points[base] + val left=HandGestures(rightHand=false).estimate(points,SpatialPose(),1_000_000_000)!! + val right=HandGestures(rightHand=true).estimate(points.map { SpatialVector(-it.x,it.y,it.z) },SpatialPose(),1_000_000_000)!! + assertEquals(left.flags(),right.flags());assertEquals(1f,right.trigger,0f);assertTrue(right.grip) + assertEquals(left.timeNs,right.timeNs) + assertVector(SpatialVector(-left.pose.position.x,left.pose.position.y,left.pose.position.z),right.pose.position) + } + private fun assertVector(expected: SpatialVector,actual: SpatialVector) { + assertEquals(expected.x,actual.x,.0001f);assertEquals(expected.y,actual.y,.0001f);assertEquals(expected.z,actual.z,.0001f) + } + @Test fun pinchAndFingerClosureProduceTriggerAndGrip() { + val detector=HandGestures(rightHand=false);val p=openHand() + detector.estimate(p,SpatialPose(),1_000_000_000) + p[4]=p[8] + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) p[tip]=p[base] + val pressed=detector.estimate(p,SpatialPose(),1_040_000_000)!! + assertEquals(1f,pressed.trigger,.0001f);assertTrue(pressed.grip) + val released=detector.estimate(openHand(),SpatialPose(),1_080_000_000)!! + assertEquals(0f,released.trigger,.0001f);assertFalse(released.grip) + } + @Test fun invalidGeometryAndImplausibleTemporalJumpAreRejected() { + val detector=HandGestures(rightHand=false) + assertNull(detector.estimate(emptyList(),SpatialPose(),1)) + assertEquals(HandObservationOutcome.LANDMARK_COUNT_INVALID,detector.lastOutcome) + assertNull(detector.estimate(List(21) { SpatialVector() },SpatialPose(),1)) + assertEquals(HandObservationOutcome.PALM_WIDTH_INVALID,detector.lastOutcome) + detector.estimate(openHand(),SpatialPose(),1_000_000_000) + assertNull(detector.estimate(openHand(),SpatialPose(SpatialVector(2f,0f,0f)),1_040_000_000)) + assertEquals(HandObservationOutcome.PALM_MOTION_REJECTED,detector.lastOutcome) + detector.reset() + assertNotNull(detector.estimate(openHand(),SpatialPose(SpatialVector(2f,0f,0f)),1_080_000_000)) + assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome) + } + @Test fun anUnreliableUnusedJointDoesNotHideThePalmOrDisableGestures() { + val points=openHand().map { it as SpatialVector? }.toMutableList() + points[6]=null + val hand=HandGestures(rightHand=false).estimate(points,SpatialPose(),1_000_000_000)!! + assertTrue(hand.valid);assertTrue(hand.triggerValid);assertTrue(hand.gripValid) + assertEquals(7,hand.flags()) + } + @Test fun repeatedMotionRejectionsPreserveTheLastPoseAndGripHysteresis() { + val detector=HandGestures(false) + val closed=openHand().apply { + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base] + } + assertTrue(detector.estimate(closed,SpatialPose(),1_000_000_000)!!.grip) + for(time in listOf(1_040_000_000L,1_080_000_000L,1_120_000_000L)) { + assertNull(detector.estimate(openHand(),SpatialPose(SpatialVector(2f,0f,0f)),time)) + assertEquals(HandObservationOutcome.PALM_MOTION_REJECTED,detector.lastOutcome) + detector.resetAfterRejection(detector.lastOutcome) + } + val partlyClosed=openHand().apply { this[12]=this[9];this[16]=this[13] } + val recovered=detector.estimate(partlyClosed,SpatialPose(),1_160_000_000)!! + assertTrue(recovered.grip) + assertEquals(1_160_000_000L,recovered.timeNs) + } + @Test fun motionRejectionDoesNotPreventReacquisitionAfterTheMotionWindow() { + val detector=HandGestures(false) + detector.estimate(openHand(),SpatialPose(),1_000_000_000) + val moved=SpatialPose(SpatialVector(2f,0f,0f)) + for(time in listOf(1_040_000_000L,1_160_000_000L)) { + assertNull(detector.estimate(openHand(),moved,time)) + detector.resetAfterRejection(detector.lastOutcome) + } + val reacquired=detector.estimate(openHand(),moved,1_200_000_000)!! + assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome) + assertEquals(1_200_000_000L,reacquired.timeNs) + } + @Test fun actualDetectionLossClearsMotionHistoryAndGripEvenAfterAMotionRejection() { + val detector=HandGestures(false) + val closed=openHand().apply { + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base] + } + assertTrue(detector.estimate(closed,SpatialPose(),1_000_000_000)!!.grip) + val moved=SpatialPose(SpatialVector(2f,0f,0f)) + assertNull(detector.estimate(closed,moved,1_040_000_000)) + detector.resetAfterRejection(detector.lastOutcome) + detector.resetAfterRejection(HandObservationOutcome.NO_MATCHING_DETECTION) + val partlyClosed=openHand().apply { this[12]=this[9];this[16]=this[13] } + val reacquired=detector.estimate(partlyClosed,moved,1_080_000_000)!! + assertFalse(reacquired.grip) + } + @Test fun occludedPinchKeepsThePalmAndIndependentGrip() { + val detector=HandGestures(rightHand=false) + val points=openHand().map { it as SpatialVector? }.toMutableList() + points[4]=points[8] + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) points[tip]=points[base] + assertEquals(1f,detector.estimate(points,SpatialPose(),1_000_000_000)!!.trigger,0f) + points[4]=null + val hand=detector.estimate(points,SpatialPose(),1_080_000_000)!! + assertTrue(hand.valid);assertFalse(hand.triggerValid);assertEquals(0f,hand.trigger,0f) + assertTrue(hand.gripValid);assertTrue(hand.grip);assertEquals(5,hand.flags()) + } + @Test fun occludedGripKeepsThePalmAndIndependentPinch() { + val points=openHand().map { it as SpatialVector? }.toMutableList() + points[4]=points[8];points[16]=SpatialVector(Float.NaN,0f,.5f) + val hand=HandGestures(rightHand=false).estimate(points,SpatialPose(),1_000_000_000)!! + assertTrue(hand.valid);assertTrue(hand.triggerValid);assertEquals(1f,hand.trigger,0f) + assertFalse(hand.gripValid);assertFalse(hand.grip);assertEquals(3,hand.flags()) + } + @Test fun missingPalmStillRejectsTheController() { + for(index in listOf(0,5,9,13,17)) { + val points=openHand().map { it as SpatialVector? }.toMutableList();points[index]=null + val detector=HandGestures(rightHand=false) + assertNull(detector.estimate(points,SpatialPose(),1_000_000_000)) + assertEquals(HandObservationOutcome.PALM_LANDMARK_MISSING,detector.lastOutcome) + assertNotNull(detector.estimate(openHand(),SpatialPose(),1_040_000_000)) + assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome) + } + assertEquals(0,SpatialHand(triggerValid=true,gripValid=true).flags()) + } + @Test fun degeneratePalmAxesAreDistinguishedFromMissingStereoLandmarks() { + val detector=HandGestures(rightHand=false) + for(middle in listOf(SpatialVector(0f,0f,.5f),SpatialVector(.04f,0f,.5f))) { + val points=openHand().apply { this[9]=middle } + assertNull(detector.estimate(points,SpatialPose(),1_000_000_000)) + assertEquals(HandObservationOutcome.PALM_BASIS_INVALID,detector.lastOutcome) + } + assertNotNull(detector.estimate(openHand(),SpatialPose(),1_040_000_000)) + assertEquals(HandObservationOutcome.ACCEPTED,detector.lastOutcome) + } + @Test fun agreeingImageCurlsAndPinchSurviveMissingTriangulatedFingertips() { + val image=openHand().apply { + this[4]=this[8] + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base] + }.map { SpatialVector(320f+it.x*1000f,240f+it.y*1000f) } + val points=openHand().map { it as SpatialVector? }.toMutableList() + for(index in listOf(4,8,12,16,20)) points[index]=null + val hand=HandGestures(false).estimate(points,SpatialPose(),1_000_000_000,image,image)!! + assertTrue(hand.valid);assertTrue(hand.gripValid);assertTrue(hand.grip) + assertTrue(hand.triggerValid);assertEquals(1f,hand.trigger,0f) + assertVector(HandGestures(false).estimate(openHand(),SpatialPose(),1_000_000_000)!!.pose.position,hand.pose.position) + } + @Test fun imageDisagreementInvalidatesGestureInsteadOfFallingBackToPressedDepth() { + val closed=openHand().apply { + this[4]=this[8] + for((tip,base) in listOf(12 to 9,16 to 13,20 to 17)) this[tip]=this[base] + } + fun image(points: List)=points.map { SpatialVector(it.x*1000f,it.y*1000f) } + val detector=HandGestures(false) + assertTrue(detector.estimate(closed,SpatialPose(),1_000_000_000,image(closed),image(closed))!!.grip) + val conflict=detector.estimate(closed,SpatialPose(),1_080_000_000,image(closed),image(openHand()))!! + assertTrue(conflict.valid);assertFalse(conflict.triggerValid);assertFalse(conflict.gripValid) + assertFalse(conflict.grip);assertEquals(0f,conflict.trigger,0f) + val missingView=detector.estimate(closed,SpatialPose(),1_120_000_000,image(closed),null)!! + assertTrue(missingView.valid);assertFalse(missingView.triggerValid);assertFalse(missingView.gripValid) + val released=detector.estimate(closed,SpatialPose(),1_160_000_000,image(openHand()),image(openHand()))!! + assertTrue(released.triggerValid);assertTrue(released.gripValid) + assertFalse(released.grip);assertEquals(0f,released.trigger,0f) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/HandImageBufferTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/HandImageBufferTest.kt new file mode 100644 index 0000000000..2dc41cf1e7 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/HandImageBufferTest.kt @@ -0,0 +1,90 @@ +package com.droiddeck.launcher.glasses + +import android.graphics.Bitmap +import android.graphics.Color +import com.google.mediapipe.framework.image.ByteBufferExtractor +import com.google.mediapipe.framework.image.MPImage +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk=[28],manifest=Config.NONE) +class HandImageBufferTest { + private fun bitmap(vararg values: Int) = Bitmap.createBitmap(values.size, 1, Bitmap.Config.ARGB_8888).apply { + setPixels(values.map { Color.rgb(it, it, it) }.toIntArray(), 0, values.size, 0, 0, values.size, 1) + } + + private fun values(buffer: HandImageBuffer, bitmap: Bitmap): List = values(buffer.image(bitmap)) + + private fun values(image: MPImage): List = image.use { + assertEquals(MPImage.IMAGE_FORMAT_RGB, image.containedImageProperties.single().imageFormat) + val pixels = ByteBufferExtractor.extract(image) + assertTrue(pixels.isDirect) + assertEquals(image.width * image.height * 3, pixels.remaining()) + List(image.width * image.height) { + val red = pixels.get().toInt() and 255 + assertEquals(red, pixels.get().toInt() and 255) + assertEquals(red, pixels.get().toInt() and 255) + red + } + } + + @Test fun liveDefaultUsesFullModelAndPreservesCameraPixelCoordinatesAndExposure() { + assertEquals(HandModel.FULL, HandModel.DEFAULT) + val input = byteArrayOf(32, 64, 96, 128.toByte(), 160.toByte(), 192.toByte()) + val original = input.copyOf() + val image = HandImageBuffer().image(input, 3, 2) + assertEquals(3, image.width); assertEquals(2, image.height) + assertEquals(listOf(32, 64, 96, 128, 160, 192), values(image)) + assertArrayEquals(original, input) + } + + @Test fun directCameraAndRawBitmapInputsMatchAcrossEveryGrayValueAndFrameSize() { + val buffer = HandImageBuffer() + for ((width, height) in listOf(16 to 16, 3 to 2, 2 to 3, 1 to 1)) { + val input = ByteArray(width * height) { ((it * 73 + 32) and 255).toByte() } + val bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888).apply { + setPixels(input.map { (it.toInt() and 255).let { value -> Color.rgb(value, value, value) } }.toIntArray(), + 0, width, 0, 0, width, height) + } + try { + val expected = input.map { it.toInt() and 255 } + assertEquals(expected, values(buffer.image(input, width, height))) + assertEquals(expected, values(buffer.image(bitmap))) + } finally { bitmap.recycle() } + } + } + + @Test(expected = IllegalArgumentException::class) + fun cameraDimensionsMustMatchTheGrayscaleFrame() { + HandImageBuffer().image(ByteArray(5), 3, 2) + } + + @Test fun resizedAndSuccessiveFramesDoNotRetainOldPixelsOrExposure() { + val buffer = HandImageBuffer() + for (input in listOf(intArrayOf(32, 96, 160), intArrayOf(64, 128, 192), intArrayOf(0, 255))) { + val bitmap = bitmap(*input) + try { + assertEquals(input.toList(), values(buffer, bitmap)) + } finally { bitmap.recycle() } + } + } + + @Test fun closingInferenceImagesDoesNotRecycleReusableCameraBitmap() { + val bitmap=Bitmap.createBitmap(2,2,Bitmap.Config.ARGB_8888) + val buffer=HandImageBuffer() + repeat(3) { frame -> + bitmap.eraseColor(if(frame%2==0) Color.WHITE else Color.BLACK) + buffer.image(bitmap).use { image -> + assertEquals(2,image.width);assertEquals(2,image.height) + val pixels=ByteBufferExtractor.extract(image) + assertEquals(if(frame%2==0) 255 else 0,pixels.get(0).toInt() and 255) + } + assertFalse(bitmap.isRecycled) + } + bitmap.recycle() + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/HandInferenceScheduleTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/HandInferenceScheduleTest.kt new file mode 100644 index 0000000000..18006947fb --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/HandInferenceScheduleTest.kt @@ -0,0 +1,128 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class HandInferenceScheduleTest { + private fun frame(schedule: HandInferenceSchedule, time: Long, left: List = listOf(0), + right: List = left, rawLeft: Int = left.size, rawRight: Int = right.size): Int { + val maximum = schedule.select(time) + schedule.observe(time, left, right, rawLeft, rawRight) + return maximum + } + + private fun stable(schedule: HandInferenceSchedule, side: Int = 0) { + for (time in listOf(0L, 80L, 160L)) assertEquals(2, frame(schedule, time, listOf(side))) + } + + @Test fun requiresThreeStereoConsistentFramesBeforeSingleHandTracking() { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(1, frame(schedule, 240)) + assertEquals(1, frame(schedule, 320)) + assertEquals(2, frame(schedule, 400)) + assertEquals(1, frame(schedule, 480)) + } + + @Test fun discoversSecondHandAtBothCameraInputCadences() { + for (cadence in listOf(40L, 80L)) { + val schedule = HandInferenceSchedule() + val searches = ArrayList() + for (time in 0L..1200L step cadence) { + if (frame(schedule, time) == 2) searches.add(time) + } + assertTrue(searches.size >= 5) + assertTrue(searches.zipWithNext().all { (first, second) -> second - first <= 240 }) + } + } + + @Test fun delayedFrameStillSearchesAtFirstFrameAfterDiscoveryDeadline() { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(1, frame(schedule, 240)) + assertEquals(1, frame(schedule, 399)) + assertEquals(2, frame(schedule, 479)) + assertEquals(1, frame(schedule, 559)) + } + + @Test fun secondHandDiscoveredBySearchKeepsBothHandDetectorsSelected() { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(1, frame(schedule, 240)) + assertEquals(2, frame(schedule, 400, listOf(0, 1))) + for (time in listOf(480L, 560L, 640L)) assertEquals(2, frame(schedule, time, listOf(1, 0))) + for (time in listOf(720L, 800L, 880L)) assertEquals(2, frame(schedule, time)) + assertEquals(1, frame(schedule, 960)) + } + + @Test fun anyCameraLossImmediatelyReturnsToFullSearch() { + for ((left, right) in listOf(emptyList() to listOf(0), listOf(0) to emptyList())) { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(1, frame(schedule, 240, left, right)) + assertEquals(2, frame(schedule, 320)) + } + } + + @Test fun ambiguousOrFilteredDetectionsNeverMaintainSingleHandMode() { + val invalid = listOf( + listOf(0) to listOf(1), + listOf(0, 0) to listOf(0), + listOf(0) to listOf(0, 0), + listOf(-1) to listOf(-1), + listOf(2) to listOf(2) + ) + for ((left, right) in invalid) { + val schedule = HandInferenceSchedule() + stable(schedule) + frame(schedule, 240, left, right) + assertEquals(2, frame(schedule, 320)) + } + for ((rawLeft, rawRight) in listOf(2 to 1, 1 to 2, 0 to 1, -1 to 1)) { + val schedule = HandInferenceSchedule() + stable(schedule) + frame(schedule, 240, rawLeft = rawLeft, rawRight = rawRight) + assertEquals(2, frame(schedule, 320)) + } + } + + @Test fun changingSidesRequiresFreshFullSearchStability() { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(1, frame(schedule, 240, listOf(1))) + for (time in listOf(320L, 400L, 480L)) assertEquals(2, frame(schedule, time, listOf(1))) + assertEquals(1, frame(schedule, 560, listOf(1))) + } + + @Test fun inconsistentInitialSidesCannotAccumulateStability() { + val schedule = HandInferenceSchedule() + for (index in 0..8) assertEquals(2, frame(schedule, index * 80L, listOf(index % 2))) + } + + @Test fun resetDropsSessionState() { + val schedule = HandInferenceSchedule() + stable(schedule) + frame(schedule, 240) + schedule.reset() + stable(schedule, 1) + assertEquals(1, frame(schedule, 240, listOf(1))) + } + + @Test fun longGapAndNonmonotonicTimeRequireFreshStability() { + for (time in listOf(160L, 120L, 561L, -1L)) { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(2, frame(schedule, time)) + assertEquals(2, frame(schedule, maxOf(0, time) + 80)) + } + } + + @Test fun unobservedInferenceAndMismatchedObservationResetSchedule() { + val schedule = HandInferenceSchedule() + stable(schedule) + assertEquals(1, schedule.select(240)) + assertEquals(2, frame(schedule, 320)) + schedule.observe(240, listOf(0), listOf(0)) + assertEquals(2, frame(schedule, 400)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/HandObservationTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/HandObservationTest.kt new file mode 100644 index 0000000000..68c09e4b9c --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/HandObservationTest.kt @@ -0,0 +1,65 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class HandObservationTest { + private val time=1_000_000_000L + private fun session()=SpatialSession().apply { + reset(7,1.6f) + accept(SpatialSample(SpatialPose(),time,7,true)) + } + private fun advance(session: SpatialSession, ms: Long, valid: Boolean=true, x: Float=.1f) { + session.accept(SpatialSample(SpatialPose(SpatialVector(x=x)),time+ms*1_000_000,7,valid)) + } + + @Test fun lateCameraConfirmationUsesTheCapturePoseInsteadOfTheLatestPose() { + val session=session() + val observation=HandObservation(time,7,session.trackingFrameGeneration) + assertNull(observation.headPose(session,false,time)) + advance(session,150) + assertEquals(SpatialPose(),observation.headPose(session,true,time+150_000_000)) + assertEquals(time,observation.timeNs) + } + + @Test fun missingConfirmationOrExpiredObservationCannotPublish() { + val session=session() + val observation=HandObservation(time,7,session.trackingFrameGeneration) + advance(session,180) + assertNull(observation.headPose(session,false,time+180_000_000)) + assertNotNull(observation.headPose(session,true,time+200_000_000)) + assertNull(observation.headPose(session,true,time+200_000_001)) + assertNull(observation.headPose(session,true,time-1)) + } + + @Test fun longerHandWindowDoesNotExtendHeadFreshness() { + val session=session() + val observation=HandObservation(time,7,session.trackingFrameGeneration) + assertNotNull(observation.headPose(session,true,time+100_000_000)) + assertNull(observation.headPose(session,true,time+100_000_001)) + advance(session,150) + assertNotNull(observation.headPose(session,true,time+150_000_000)) + } + + @Test fun trackingLossAndRecoveredDiscontinuityInvalidateInFlightInference() { + val session=session() + val observation=HandObservation(time,7,session.trackingFrameGeneration) + advance(session,20,valid=false) + assertNull(observation.headPose(session,true,time+20_000_000)) + advance(session,30,x=5f) + assertNull(observation.headPose(session,true,time+30_000_000)) + session.setFloor(1.6f,time+30_000_000) + assertTrue(session.valid(time+30_000_000)) + assertNull(observation.headPose(session,true,time+30_000_000)) + } + + @Test fun reconnectAndMissingHistoryCannotBorrowAnotherPose() { + val session=session() + val observation=HandObservation(time,7,session.trackingFrameGeneration) + advance(session,40) + assertNull(observation.copy(timeNs=time+20_000_000).headPose(session,true,time+40_000_000)) + session.reset(8,1.6f) + session.accept(SpatialSample(SpatialPose(),time+50_000_000,8,true)) + assertNull(observation.headPose(session,true,time+50_000_000)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/HandProcessingRateTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/HandProcessingRateTest.kt new file mode 100644 index 0000000000..2cba38ff3d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/HandProcessingRateTest.kt @@ -0,0 +1,119 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class HandProcessingRateTest { + private fun sample(rate: HandProcessingRate, processingMs: Long = 35, ageMs: Long = 65, + healthy: Boolean = true): Int = + rate.observe(processingMs * 1_000_000, ageMs * 1_000_000, healthy) + + private fun fastest(rate: HandProcessingRate) { + repeat(16) { sample(rate) } + assertEquals(800, rate.permille) + } + + @Test fun beginsConservativelyAndRequiresEightHealthySamplesPerIncrease() { + val rate = HandProcessingRate() + assertEquals(500, rate.permille) + repeat(7) { assertEquals(500, sample(rate)) } + assertEquals(600, sample(rate)) + repeat(7) { assertEquals(600, sample(rate)) } + assertEquals(800, sample(rate)) + repeat(20) { assertEquals(800, sample(rate)) } + } + + @Test fun onlySelectsFifteenHzWhenTwentyHzHasInsufficientHeadroom() { + val rate = HandProcessingRate() + repeat(8) { sample(rate, 50, 80) } + assertEquals(600, rate.permille) + repeat(30) { assertEquals(600, sample(rate, 50, 80)) } + } + + @Test fun slowProcessingStaysAtTwelvePointFiveHz() { + val rate = HandProcessingRate() + repeat(30) { assertEquals(500, sample(rate, 60, 100)) } + } + + @Test fun sustainedProcessingPastTheCurrentPeriodReducesRate() { + val rate = HandProcessingRate() + fastest(rate) + repeat(2) { assertEquals(800, sample(rate, 70)) } + assertEquals(600, sample(rate, 70)) + repeat(7) { assertEquals(600, sample(rate, 70)) } + assertEquals(500, sample(rate, 70)) + repeat(7) { assertEquals(500, sample(rate)) } + } + + @Test fun largeProcessingSpikeSkipsDirectlyToConservativeRate() { + val rate = HandProcessingRate() + fastest(rate) + assertEquals(500, sample(rate, 80, 100)) + } + + @Test fun ageLimitReducesRateWithoutWaitingForProcessingAverage() { + val rate = HandProcessingRate() + fastest(rate) + assertEquals(500, sample(rate, ageMs = 140)) + repeat(7) { assertEquals(500, sample(rate)) } + assertEquals(600, sample(rate)) + } + + @Test fun agingFramesCannotRaiseTheRate() { + val rate = HandProcessingRate() + repeat(30) { assertEquals(500, sample(rate, ageMs = 111)) } + repeat(8) { sample(rate, ageMs = 100) } + assertEquals(600, rate.permille) + repeat(30) { assertEquals(600, sample(rate, ageMs = 91)) } + } + + @Test fun marginalHeadroomInterruptsConsecutiveUpshiftSamples() { + val rate = HandProcessingRate() + repeat(7) { sample(rate, 55) } + assertEquals(500, sample(rate, 60)) + repeat(7) { assertEquals(500, sample(rate)) } + assertEquals(600, sample(rate)) + } + + @Test fun recoveryMustAlsoBringAverageProcessingBelowUpshiftThreshold() { + val rate = HandProcessingRate() + sample(rate, 100) + repeat(8) { assertEquals(500, sample(rate)) } + repeat(8) { sample(rate) } + assertEquals(600, rate.permille) + } + + @Test fun trackingLossAndInvalidTimingResetTheRateAndHistory() { + for (invalid in listOf(Triple(35_000_000L, 65_000_000L, false), + Triple(0L, 65_000_000L, true), Triple(-1L, 65_000_000L, true), + Triple(35_000_000L, -1L, true))) { + val rate = HandProcessingRate() + fastest(rate) + assertEquals(500, rate.observe(invalid.first, invalid.second, invalid.third)) + repeat(7) { assertEquals(500, sample(rate)) } + assertEquals(600, sample(rate)) + } + } + + @Test fun lifecycleResetDropsOldHeadroom() { + val rate = HandProcessingRate() + fastest(rate) + assertEquals(500, rate.reset()) + repeat(7) { assertEquals(500, sample(rate)) } + assertEquals(600, sample(rate)) + } + + @Test fun periodicDiscoverySearchesPermitFifteenHzButNotTwentyHz() { + val rate = HandProcessingRate() + repeat(8) { sample(rate, if (it % 3 == 2) 74 else 36, 90) } + assertEquals(600, rate.permille) + for (frame in 8 until 90) { + assertEquals(600, sample(rate, if (frame % 3 == 2) 74 else 36, 90)) + } + } + + @Test fun continuouslySlowDiscoveryCannotRaiseRate() { + val rate = HandProcessingRate() + repeat(30) { assertEquals(500, sample(rate, 70, 100)) } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/HandTrackingMetricsTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/HandTrackingMetricsTest.kt new file mode 100644 index 0000000000..2311d0c470 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/HandTrackingMetricsTest.kt @@ -0,0 +1,119 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class HandTrackingMetricsTest { + private val missing = HandObservationDiagnostic(HandObservationOutcome.NO_MATCHING_DETECTION) + private fun accepted(trigger: Float = 0f, grip: Boolean = false) = HandObservationDiagnostic( + HandObservationOutcome.ACCEPTED, listOf(0,5,9,13,17), trigger, true, grip, true) + + @Test fun cameraSequencesCountOnceAndSkippedPairsAreNotInvented() { + val metrics = HandTrackingMetrics() + metrics.observe(0, true, accepted(), accepted()) + metrics.observe(10, true, accepted(), missing) + metrics.observe(10, true, missing, accepted()) + metrics.observe(9, true, missing, accepted()) + metrics.observe(15, true, accepted(), missing) + val result = metrics.snapshot() + assertEquals(2L, result.processedPairs) + assertEquals(2L, result.inferencePairs) + assertEquals(2L, result.left.accepted) + assertEquals(0L, result.right.accepted) + assertEquals(2L, result.right.observations) + assertEquals(0L, result.left.trackingLosses) + } + + @Test fun setupAndUnavailableFramesRemainDistinctFromInference() { + val metrics = HandTrackingMetrics() + val setup = HandObservationDiagnostic(HandObservationOutcome.CALIBRATION_REQUIRED) + val unavailable = HandObservationDiagnostic(HandObservationOutcome.INFERENCE_UNAVAILABLE) + metrics.observe(1, false, setup, setup) + metrics.observe(2, false, unavailable, unavailable) + metrics.observe(3, true, accepted(), missing) + val result = metrics.snapshot() + assertEquals(3L, result.processedPairs) + assertEquals(1L, result.inferencePairs) + assertEquals(3L, result.left.observations) + assertEquals(1L, result.left.accepted) + assertEquals(1L, result.left.outcomes[HandObservationOutcome.CALIBRATION_REQUIRED]) + assertEquals(1L, result.left.outcomes[HandObservationOutcome.INFERENCE_UNAVAILABLE]) + assertEquals(3L, result.right.maximumConsecutiveRejected) + } + + @Test fun countsGestureLossesIndependentlyFromPalmLossAndOtherHand() { + val metrics = HandTrackingMetrics() + metrics.observe(1, true, accepted(), accepted()) + metrics.observe(2, true, accepted().copy(triggerGeometryValid = false), accepted()) + metrics.observe(3, true, accepted().copy(gripGeometryValid = false), accepted()) + metrics.observe(4, true, missing, accepted()) + metrics.observe(5, true, missing, accepted()) + val result = metrics.snapshot() + assertEquals(3L, result.left.accepted) + assertEquals(1L, result.left.trackingLosses) + assertEquals(2L, result.left.triggerLosses) + assertEquals(1L, result.left.gripLosses) + assertEquals(2L, result.left.maximumConsecutiveRejected) + assertEquals(0L, result.right.trackingLosses) + assertEquals(0L, result.right.triggerLosses) + assertEquals(0L, result.right.gripLosses) + } + + @Test fun rejectedObservationRetainsRawEstimatesButCannotCountUsableInputs() { + val metrics = HandTrackingMetrics() + val stale = accepted(1f, true).copy(outcome = HandObservationOutcome.STALE_OBSERVATION) + assertEquals(1f, stale.triggerEstimate, 0f) + assertTrue(stale.gripEstimate) + assertTrue(stale.triggerGeometryValid) + assertFalse(stale.accepted) + assertFalse(stale.triggerValid) + assertFalse(stale.gripValid) + metrics.observe(1, true, stale, stale) + val side = metrics.snapshot().left + assertEquals(0L, side.accepted) + assertEquals(0L, side.triggerValid) + assertEquals(0L, side.gripValid) + assertEquals(0L, side.triggerAboveClickThreshold) + assertEquals(0L, side.gripPressed) + } + + @Test fun thresholdCountsDescribeValidEstimatesWithoutClaimingDriverPresses() { + val metrics = HandTrackingMetrics() + for ((index, trigger) in listOf(0f, .25f, .65f, 1f).withIndex()) + metrics.observe(index + 1L, true, accepted(trigger, index == 3), missing) + metrics.observe(5, true, accepted(1f, true).copy(triggerGeometryValid = false, gripGeometryValid = false), missing) + val side = metrics.snapshot().left + assertEquals(5L, side.accepted) + assertEquals(4L, side.triggerValid) + assertEquals(4L, side.gripValid) + assertEquals(1L, side.triggerAboveClickThreshold) + assertEquals(1L, side.triggerReleased) + assertEquals(1L, side.gripPressed) + } + + @Test fun snapshotsRetainTheirCountsWhenLaterFramesArrive() { + val metrics = HandTrackingMetrics() + metrics.observe(1, true, accepted(), missing) + val first = metrics.snapshot() + metrics.observe(2, true, missing, accepted()) + assertEquals(1L, first.processedPairs) + assertEquals(mapOf(HandObservationOutcome.ACCEPTED to 1L), first.left.outcomes) + assertEquals(0L, first.left.trackingLosses) + assertEquals(2L, metrics.snapshot().processedPairs) + assertEquals(1L, metrics.snapshot().left.trackingLosses) + } + + @Test fun aNewTrackingConnectionStartsCountsAndSequenceFromZero() { + val old = HandTrackingMetrics() + old.observe(500, true, accepted(), missing) + old.observe(501, true, missing, missing) + val current = HandTrackingMetrics() + assertEquals(0L, current.snapshot().processedPairs) + current.observe(1, true, accepted(), accepted()) + val result = current.snapshot() + assertEquals(1L, result.processedPairs) + assertEquals(1L, result.left.accepted) + assertEquals(0L, result.left.trackingLosses) + assertEquals(0L, result.right.maximumConsecutiveRejected) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/JoyConFlowGateTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/JoyConFlowGateTest.kt new file mode 100644 index 0000000000..d096fd8c8f --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/JoyConFlowGateTest.kt @@ -0,0 +1,23 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class JoyConFlowGateTest { + @Test fun missingDetectionsCannotExtendTheSeedLifetime() { + val seed = 1_000_000_000L + assertTrue(JoyConFlowGate.fresh(seed, seed + 640_000_000, seed + 720_000_000)) + assertFalse(JoyConFlowGate.fresh(seed, seed + 720_000_000, seed + 800_000_000)) + assertFalse(JoyConFlowGate.fresh(seed, seed, seed + 200_000_001)) + assertFalse(JoyConFlowGate.fresh(seed, seed, seed)) + } + + @Test fun featureMustBeVisibleAndReturnToItsOriginalLocation() { + assertTrue(JoyConFlowGate.point(110.0,105.0,100.5,100.5,100.0,100.0,5f,true,true,640,480)) + assertFalse(JoyConFlowGate.point(110.0,105.0,103.0,100.0,100.0,100.0,5f,true,true,640,480)) + assertFalse(JoyConFlowGate.point(110.0,105.0,100.0,100.0,100.0,100.0,30f,true,true,640,480)) + assertFalse(JoyConFlowGate.point(110.0,105.0,100.0,100.0,100.0,100.0,5f,false,true,640,480)) + assertFalse(JoyConFlowGate.point(Double.NaN,105.0,100.0,100.0,100.0,100.0,5f,true,true,640,480)) + assertFalse(JoyConFlowGate.point(640.0,105.0,100.0,100.0,100.0,100.0,5f,true,true,640,480)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/JoyConWristPositionTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/JoyConWristPositionTest.kt new file mode 100644 index 0000000000..69d6e068fa --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/JoyConWristPositionTest.kt @@ -0,0 +1,69 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class JoyConWristPositionTest { + private fun points(depth: Float = .4f): MutableList = MutableList(21) { null }.apply { + this[0] = SpatialVector(0f, 0f, depth) + this[5] = SpatialVector(.035f, -.06f, depth) + this[9] = SpatialVector(0f, -.065f, depth) + this[13] = SpatialVector(-.02f, -.06f, depth) + this[17] = SpatialVector(-.045f, -.05f, depth) + } + + @Test fun grippingControllerNeedsOnlyTheWristAndNeverGeneratesFingerGestures() { + val estimator = JoyConWristPosition() + val full = estimator.estimate(points(), SpatialPose(), 1_000_000_000)!! + val occluded = MutableList(21) { null }.apply { this[0] = points()[0] } + val grip = estimator.estimate(occluded, SpatialPose(), 1_080_000_000)!! + assertEquals(occluded[0], grip.pose.position) + assertEquals(full.pose.position, grip.pose.position) + assertTrue(grip.valid) + assertFalse(grip.triggerValid) + assertFalse(grip.gripValid) + assertNull(HandGestures(false).estimate(occluded, SpatialPose(), 1_080_000_000)) + } + + @Test fun erroneousKnucklesCannotMoveOrRejectTheWrist() { + val malformed = points().apply { + this[5] = SpatialVector(Float.NaN, 0f, .4f) + this[9] = SpatialVector(4f, 5f, 6f) + this[13] = this[0] + this[17] = null + } + val grip = JoyConWristPosition().estimate(malformed, SpatialPose(), 1)!! + assertEquals(malformed[0], grip.pose.position) + } + + @Test fun measuredExtensionMovesTheWorldPositionByTheSameDistance() { + val estimator = JoyConWristPosition() + val world = SpatialPose(SpatialVector(1f, 2f, 3f), SpatialRotation(y = 1f, w = 0f)) + val near = estimator.estimate(points(.3f).take(1), world, 1_000_000_000)!! + val far = estimator.estimate(points(.7f).take(1), world, 1_300_000_000)!! + assertEquals(SpatialVector(1f, 2f, 2.7f), near.pose.position) + assertEquals(-.4f, far.pose.position.z - near.pose.position.z, .0001f) + assertEquals(near.pose.position.x, far.pose.position.x, .0001f) + assertEquals(1_300_000_000, far.timeNs) + } + + @Test fun missingOrNonfiniteWristIsRejectedEvenWithVisibleKnuckles() { + for (wrist in listOf(null, SpatialVector(Float.NaN, 0f, .4f), SpatialVector(0f, 0f, Float.POSITIVE_INFINITY))) { + val estimator = JoyConWristPosition() + assertNull(estimator.estimate(points().apply { this[0] = wrist }, SpatialPose(), 1)) + assertEquals(HandObservationOutcome.WRIST_LANDMARK_MISSING, estimator.lastOutcome) + } + assertNull(JoyConWristPosition().estimate(emptyList(), SpatialPose(), 1)) + } + + @Test fun implausibleJumpsAndRepeatedFramesStayRejectedWithoutPoisoningTheLastPosition() { + val estimator = JoyConWristPosition() + assertNotNull(estimator.estimate(points(), SpatialPose(), 1_000_000_000)) + assertNull(estimator.estimate(points(1.2f), SpatialPose(), 1_080_000_000)) + assertEquals(HandObservationOutcome.WRIST_MOTION_REJECTED, estimator.lastOutcome) + assertNull(estimator.estimate(points(), SpatialPose(), 1_000_000_000)) + assertNotNull(estimator.estimate(points(.45f).take(1), SpatialPose(), 1_090_000_000)) + estimator.reset() + assertNotNull(estimator.estimate(points(1.2f).take(1), SpatialPose(), 1_100_000_000)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/LumaRgbDiagnosticTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/LumaRgbDiagnosticTest.kt new file mode 100644 index 0000000000..91174de496 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/LumaRgbDiagnosticTest.kt @@ -0,0 +1,73 @@ +package com.droiddeck.launcher.glasses + +import android.app.Application +import android.os.SystemClock +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.json.JSONObject +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import java.io.File + +@RunWith(RobolectricTestRunner::class) +@Config(application = Application::class) +class LumaRgbDiagnosticTest { + private val context get() = RuntimeEnvironment.getApplication() + private val statusFile get() = File(context.filesDir, "spatial/rgb-diagnostic.json") + + @Before fun reset() { statusFile.delete(); statusFile.parentFile?.mkdirs() } + + @Test fun aDeadWorkerOrPreviousBootCannotLeaveCapturePermanentlyBusy() { + for (started in listOf(SystemClock.elapsedRealtime() - 16_000, SystemClock.elapsedRealtime() + 5_000)) { + statusFile.writeText("""{"state":"capturing","startedMs":$started}""") + assertEquals("failed", LumaRgbDiagnostic.status(context).getString("state")) + } + } + + @Test fun onlyPendingCapturesExpire() { + statusFile.writeText("""{"state":"completed","path":"saved-capture"}""") + assertEquals("completed", LumaRgbDiagnostic.status(context).getString("state")) + statusFile.writeText("""{"state":"capturing","startedMs":${SystemClock.elapsedRealtime()}}""") + assertEquals("capturing", LumaRgbDiagnostic.status(context).getString("state")) + } + + @Test fun longerReliabilityCaptureRemainsBusyUntilItsBoundedDeadline() { + val started = SystemClock.elapsedRealtime() - 20_000 + statusFile.writeText("""{"state":"capturing","startedMs":$started,"timeoutMs":45000}""") + assertEquals("capturing", LumaRgbDiagnostic.status(context).getString("state")) + statusFile.writeText("""{"state":"capturing","startedMs":${started-30_000},"timeoutMs":999999}""") + assertEquals("failed", LumaRgbDiagnostic.status(context).getString("state")) + } + + @Test fun terminalResultWaitsForWorkerExitBeforeAnotherRequest() { + for (result in listOf("completed","failed")) { + val record=JSONObject().put("state",result).put("workerPid",123).put("startedMs",1000) + val finishing=LumaRgbDiagnostic.resolveStatus(JSONObject(record.toString()),2000,true) + assertEquals("capturing",finishing.getString("state")) + assertEquals("finishing",finishing.getString("phase")) + assertEquals(result,finishing.getString("resultState")) + assertTrue(finishing.getBoolean("busy")) + val exited=LumaRgbDiagnostic.resolveStatus(record,2000,false) + assertEquals(result,exited.getString("state")) + assertFalse(exited.getBoolean("busy")) + } + } + + @Test fun deadWorkerFailsImmediatelyAndExpiredWorkerRemainsBusyOnlyUntilExit() { + val record=JSONObject().put("state","capturing").put("workerPid",123).put("startedMs",1000) + val dead=LumaRgbDiagnostic.resolveStatus(JSONObject(record.toString()),2000,false) + assertEquals("failed",dead.getString("state")) + assertFalse(dead.getBoolean("busy")) + val expired=LumaRgbDiagnostic.resolveStatus(JSONObject(record.toString()),17000,true) + assertEquals("failed",expired.getString("state")) + assertTrue(expired.getBoolean("busy")) + val exited=LumaRgbDiagnostic.resolveStatus(record,17000,false) + assertEquals("failed",exited.getString("state")) + assertFalse(exited.getBoolean("busy")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/SpatialControllerModeTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/SpatialControllerModeTest.kt new file mode 100644 index 0000000000..ec647f69c6 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/SpatialControllerModeTest.kt @@ -0,0 +1,77 @@ +package com.droiddeck.launcher.glasses + +import java.nio.ByteBuffer +import java.nio.ByteOrder +import org.junit.After +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], manifest = Config.NONE) +class SpatialControllerModeTest { + private fun snapshot(): ByteBuffer = (SpatialTracking::class.java.getDeclaredField("buffer") + .apply { isAccessible = true }.get(null) as ByteBuffer).duplicate().order(ByteOrder.LITTLE_ENDIAN) + + @After fun cleanUp() { + SpatialTracking.setSteadyHandAim(false) + SpatialTracking.setControllers(false, false) + SpatialTracking.disconnect() + } + + @Test fun joyConModeStartsStereoWithoutSelectingGestureControllersAndPersistsAcrossLoss() { + SpatialTracking.connect(0, 1, null, true, 1.6f, false, true) + assertTrue(SpatialTracking.handsEnabled) + assertEquals(4, snapshot().getInt(4)) + assertEquals(5, snapshot().getInt(32)) + SpatialTracking.disconnect() + assertFalse(SpatialTracking.handsEnabled) + assertEquals(5, snapshot().getInt(32)) + assertEquals(0, snapshot().getInt(76)) + SpatialTracking.setControllers(false, false) + assertEquals(1, snapshot().getInt(32)) + } + + @Test fun steadyAimIsOptInAndOnlyAppliesToBareHands() { + assertFalse(GlassesSettings().steadyHandAim) + SpatialTracking.connect(0, 4, null, true, 1.6f, true) + assertEquals(3, snapshot().getInt(32)) + SpatialTracking.setSteadyHandAim(true) + assertEquals(11, snapshot().getInt(32)) + SpatialTracking.setControllers(false, true) + assertEquals(5, snapshot().getInt(32)) + SpatialTracking.setControllers(true, false) + assertEquals(11, snapshot().getInt(32)) + SpatialTracking.setSteadyHandAim(false) + assertEquals(3, snapshot().getInt(32)) + SpatialTracking.connect(0, 5, null, true, 1.6f, true, steadyAim = true) + assertEquals(11, snapshot().getInt(32)) + SpatialTracking.useLegacyTracking() + assertEquals(0, snapshot().getInt(32)) + } + + @Test fun openingOtherGlassesClearsTheRetainedUltraMode() { + SpatialTracking.connect(0, 3, null, true, 1.6f, false, true) + SpatialTracking.disconnect() + assertEquals(5, snapshot().getInt(32)) + SpatialTracking.useLegacyTracking() + assertEquals(0, snapshot().getInt(32)) + assertFalse(SpatialTracking.enabled) + assertFalse(SpatialTracking.handsEnabled) + } + + @Test fun switchingControllerModesClearsOldStereoObservations() { + SpatialTracking.connect(0, 2, null, true, 1.6f, true) + assertEquals(3, snapshot().getInt(32)) + SpatialTracking.setControllers(false, true) + assertTrue(SpatialTracking.handsEnabled) + assertEquals(5, snapshot().getInt(32)) + SpatialTracking.setControllers(true, false) + assertEquals(3, snapshot().getInt(32)) + SpatialTracking.setControllers(false, false) + assertFalse(SpatialTracking.handsEnabled) + assertEquals(1, snapshot().getInt(32)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/SpatialMeasurementsTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/SpatialMeasurementsTest.kt new file mode 100644 index 0000000000..23098d180b --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/SpatialMeasurementsTest.kt @@ -0,0 +1,25 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test +import java.util.Locale + +class SpatialMeasurementsTest { + @Test fun validationKeepsExactImperialAndMetricMeasurements() { + assertEquals(0.3048f, CalibrationDistance.INCHES_12.meters, 0.000001f) + assertEquals(0.3f, CalibrationDistance.CENTIMETERS_30.meters, 0.000001f) + assertEquals(0.508f, CalibrationDistance.INCHES_20.meters, 0.000001f) + assertEquals(0.5f, CalibrationDistance.CENTIMETERS_50.meters, 0.000001f) + } + + @Test fun heightCarriesRoundedInchesIntoFeetAndAlwaysShowsBothUnits() { + val previous = Locale.getDefault() + try { + Locale.setDefault(Locale.US) + assertEquals("160 cm (5 ft 3.0 in)", SpatialMeasurements.height(160)) + assertEquals("183 cm (6 ft 0.0 in)", SpatialMeasurements.height(183)) + assertEquals("1.0 m (3.3 ft)", SpatialMeasurements.distance(1f)) + assertEquals("50.8 cm (20.00 in)", SpatialMeasurements.validation(0.508f)) + } finally { Locale.setDefault(previous) } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/SpatialPoseTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/SpatialPoseTest.kt new file mode 100644 index 0000000000..202de78ed9 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/SpatialPoseTest.kt @@ -0,0 +1,310 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test +import kotlin.math.sqrt + +class SpatialPoseTest { + private val t=1_000_000_000L + private fun sample(x: Float=0f,y: Float=0f,z: Float=0f,time: Long=t,generation: Long=7,valid: Boolean=true, + rotation: SpatialRotation=SpatialRotation())=SpatialSample(SpatialPose(SpatialVector(x,y,z),rotation),time,generation,valid) + private fun session()=SpatialSession().apply { reset(7,1.6f);accept(sample()) } + private fun near(expected: Float,actual: Float)=assertEquals(expected,actual,0.0001f) + + @Test fun sdkPoseKeepsMetersAndCanonicalAxes() { + val p=SpatialPose.fromSdk(floatArrayOf(1f,2f,-3f,1.1f,0f,0f,0f))!! + assertEquals(SpatialVector(1f,2f,-3f),p.position);near(1f,p.rotation.w) + assertNull(SpatialPose.fromSdk(floatArrayOf(0f,0f,0f,0f,0f,0f,0f))) + assertNull(SpatialPose.fromSdk(floatArrayOf(Float.NaN,0f,0f,1f,0f,0f,0f))) + } + @Test fun quaternionRotationAndInverseAgree() { + val q=SpatialRotation(y=sqrt(0.5f),w=sqrt(0.5f)) + val p=SpatialPose(SpatialVector(1f,2f,3f),q) + val front=q.apply(SpatialVector(z=-1f));near(-1f,front.x);near(0f,front.z) + val inverse=p.inverse()*p;near(0f,inverse.position.length());near(1f,inverse.rotation.w) + } + @Test fun floorSurvivesCrouchedRecenter() { + val s=session();s.accept(sample(x=.2f,y=-.3f,time=t+10));s.recenter(false,t+10) + near(1.3f,s.view(false)!!.position.y);near(0f,s.view(false)!!.position.x) + s.accept(sample(x=.2f,time=t+20));near(1.6f,s.view(false)!!.position.y) + } + @Test fun screenAndVrOriginsStayIndependent() { + val s=session();s.accept(sample(x=.2f,time=t+10));s.recenter(true,t+10) + near(0f,s.view(true)!!.position.x);near(.2f,s.view(false)!!.position.x) + s.accept(sample(x=.3f,time=t+20));s.recenter(false,t+20) + near(.1f,s.view(true)!!.position.x);near(0f,s.view(false)!!.position.x) + } + @Test fun screenRecenterPreservesRecliningRotation() { + val s=SpatialSession();s.reset(7,1.6f) + val tilt=SpatialRotation(x=sqrt(.5f),w=sqrt(.5f)) + s.accept(sample(rotation=tilt));near(1f,s.view(true)!!.rotation.w) + near(tilt.x,s.view(false)!!.rotation.x) + } + @Test fun staleHeadFreezesViewAndRejectsOldConnection() { + val s=session();s.accept(sample(x=.1f,time=t+10));val last=s.view(false) + assertFalse(s.accept(sample(x=99f,time=t+20,generation=6))) + s.accept(sample(time=t+20,valid=false));assertEquals(last,s.view(false));assertFalse(s.valid(t+21)) + s.accept(sample(x=.1f,time=t+30));assertFalse(s.valid(t+100_000_031)) + assertFalse(s.accept(sample(x=Float.NaN,time=t+40)));assertEquals(last,s.view(false)) + } + @Test fun discontinuityRequiresExplicitRecovery() { + val s=session();assertFalse(s.accept(sample(x=5f,time=t+10))) + assertTrue(s.needsRecenter);assertFalse(s.valid(t+10));near(0f,s.view(false)!!.position.x) + s.recenter(false,t+10);assertTrue(s.recenterPending);assertFalse(s.valid(t+10)) + for (i in 1..6) s.accept(sample(x=5f,time=t+i*50_000_000L)) + assertTrue(s.valid(t+300_000_000));near(0f,s.view(false)!!.position.x) + s.reset(8,1.6f,true);s.accept(sample(generation=8,time=t+400_000_000));assertFalse(s.valid(t+400_000_000)) + s.recenter(false,t+400_000_000) + for (i in 1..6) s.accept(sample(generation=8,time=t+400_000_000+i*50_000_000L)) + assertTrue(s.valid(t+700_000_000)) + } + @Test fun recenterDuringLostTrackingWaitsForSteadySamplesInsteadOfDroppingTheRequest() { + val s=session();s.accept(sample(time=t+10,valid=false));val frozen=s.view(false) + s.recenter(false,t+20);assertTrue(s.recenterPending) + s.accept(sample(x=.2f,time=t+50_000_000)) + assertFalse(s.valid(t+50_000_000));assertEquals(frozen,s.view(false)) + for(i in 2..6) s.accept(sample(x=.2f,time=t+i*50_000_000L)) + assertFalse(s.recenterPending);assertTrue(s.valid(t+300_000_000));near(0f,s.view(false)!!.position.x) + near(1.6f,s.view(false)!!.position.y) + } + @Test fun staleRecenterWaitsAndRepeatedTapsDoNotRestartTheWait() { + val s=session();s.recenter(true,t+200_000_000);assertTrue(s.recenterPending) + s.accept(sample(x=.2f,time=t+250_000_000)) + s.recenter(true,t+250_000_000) + for(i in 1..5) s.accept(sample(x=.2f,time=t+250_000_000+i*50_000_000L)) + assertFalse(s.recenterPending);near(0f,s.view(true)!!.position.x) + near(.2f,s.view(false)!!.position.x) + } + @Test fun unstableOrInterruptedRecoveryCannotAcceptANewOrigin() { + val s=session();s.accept(sample(x=5f,time=t+10));s.recenter(false,t+10) + for(i in 1..8) s.accept(sample(x=5f+(i%2)*.1f,time=t+i*50_000_000L)) + assertTrue(s.recenterPending);assertTrue(s.needsRecenter) + s.accept(sample(x=5f,time=t+450_000_000)) + s.accept(sample(x=5f,time=t+500_000_000,valid=false)) + s.accept(sample(x=5f,time=t+550_000_000)) + assertTrue(s.recenterPending) + for(i in 1..5) s.accept(sample(x=5f,time=t+550_000_000+i*50_000_000L)) + assertFalse(s.recenterPending);assertTrue(s.valid(t+800_000_000)) + } + @Test fun disconnectCancelsQueuedRecenterAndOldSamplesCannotCompleteIt() { + val s=session();s.recenter(false,t+200_000_000);assertTrue(s.recenterPending) + s.reset(8,1.6f,true);assertFalse(s.recenterPending) + for(i in 1..10) s.accept(sample(time=t+i*50_000_000L)) + assertTrue(s.needsRecenter);assertNull(s.latest()) + s.accept(sample(generation=8,time=t+600_000_000));assertFalse(s.valid(t+600_000_000)) + } + @Test fun recoverableQuaternionScaleDoesNotCreateFalseDiscontinuities() { + val s=session() + for(i in 1..4) assertTrue(s.accept(sample(time=t+i,rotation=SpatialRotation(w=.8f)))) + assertFalse(s.needsRecenter);near(1f,s.latest()!!.pose.rotation.w) + } + @Test fun calibrationFrameChangesOnlyWhenTheTrackingFrameChanges() { + val s=session();val frame=s.trackingFrameGeneration + s.recenter(false,t);assertEquals(frame,s.trackingFrameGeneration) + s.accept(sample(x=5f,time=t+10));assertEquals(frame+1,s.trackingFrameGeneration) + s.accept(sample(x=5f,time=t+20));assertEquals(frame+1,s.trackingFrameGeneration) + s.reset(8,1.6f,true);assertEquals(frame+2,s.trackingFrameGeneration) + } + @Test fun captureRemainsValidWhenHeadPollingAdvancesDuringBoardDetection() { + val s=session();val frame=s.trackingFrameGeneration + val detectionStarted=t+1_000_000L + s.accept(sample(x=.01f,time=t+20_000_000L)) + assertFalse(s.valid(detectionStarted)) + assertTrue(s.isCurrentTrackingFrame(7,frame) { t+25_000_000L }) + } + @Test fun captureCompletionStillRejectsStaleChangedAndDisconnectedTracking() { + val s=session();val frame=s.trackingFrameGeneration + assertFalse(s.isCurrentTrackingFrame(7,frame) { t+100_000_001L }) + s.accept(sample(x=5f,time=t+10));assertFalse(s.isCurrentTrackingFrame(7,frame) { t+20 }) + s.recenter(false,t+20) + for(i in 1..6) s.accept(sample(x=5f,time=t+i*50_000_000L)) + assertTrue(s.valid(t+300_000_000L)) + assertFalse(s.isCurrentTrackingFrame(7,frame) { t+300_000_000L }) + s.reset(8,1.6f);s.accept(sample(generation=8,time=t+400_000_000L)) + assertFalse(s.isCurrentTrackingFrame(7,frame) { t+400_000_000L }) + } + @Test fun newerHeadDoesNotRefreshOlderHand() { + val s=session();s.setHands(7,SpatialHand(SpatialPose(),t,true,1f,true),SpatialHand()) + s.accept(sample(time=t+80_000_000)) + s.accept(sample(time=t+150_000_000));assertTrue(s.hand(0,t+200_000_000).valid) + assertEquals(t,s.hand(0,t+200_000_000).timeNs) + assertFalse(s.hand(0,t+200_000_001).valid) + s.recenter(false,t+200_000_001);assertFalse(s.hand(0,t+200_000_001).valid) + s.reset(8,1.6f);s.setHands(7,SpatialHand(timeNs=t,valid=true),SpatialHand());assertFalse(s.hand(0,t).valid) + } + private fun heldHand(time: Long = t) = SpatialHand(timeNs=time,valid=true,trigger=1f,grip=true) + private fun epochs(session: SpatialSession) = List(4) { (session.inputEpochs() ushr (it*8)) and 0xff } + @Test fun overwrittenHandLossRemainsVisibleAfterHeldGestureReturns() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.setHands(7,SpatialHand(),heldHand(t+10)) + s.setHands(7,heldHand(t+20),heldHand(t+20)) + assertEquals(listOf(1,1,0,0),epochs(s)) + assertTrue(s.hand(0,t+20).valid);assertTrue(s.hand(0,t+20).grip) + assertEquals(listOf(1,1,0,0),epochs(s)) + } + @Test fun triggerAndGripLossEpochsAreIndependentForBothHands() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.setHands(7,heldHand(t+10).copy(triggerValid=false),heldHand(t+10)) + assertEquals(listOf(1,0,0,0),epochs(s)) + assertTrue(s.hand(0,t+10).gripValid) + s.setHands(7,heldHand(t+20).copy(gripValid=false),heldHand(t+20).copy(triggerValid=false)) + assertEquals(listOf(1,1,1,0),epochs(s)) + s.setHands(7,heldHand(t+30).copy(gripValid=false),heldHand(t+30).copy(triggerValid=false)) + assertEquals(listOf(1,1,1,0),epochs(s)) + assertFalse(s.hand(0,t+30).gripValid);assertTrue(s.hand(0,t+30).triggerValid) + } + @Test fun overwrittenHeadLossDoesNotLoseTheInputReset() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.accept(sample(time=t+10,valid=false)) + s.accept(sample(time=t+20)) + s.setHands(7,heldHand(t+20),heldHand(t+20)) + assertEquals(listOf(1,1,1,1),epochs(s)) + assertTrue(s.hand(0,t+20).triggerValid) + } + @Test fun headGapClearsCachedHandsEvenWithoutAnInvalidSnapshot() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.accept(sample(time=t+100_000_001)) + assertFalse(s.hand(0,t+100_000_001).valid) + assertEquals(listOf(1,1,1,1),epochs(s)) + s.setHands(7,heldHand(t+110_000_000),heldHand(t+110_000_000)) + assertTrue(s.hand(0,t+110_000_000).valid) + assertEquals(listOf(1,1,1,1),epochs(s)) + } + @Test fun latePreLossCaptureCannotRearmAnInputAfterHeadRecovery() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.accept(sample(time=t+20,valid=false));s.accept(sample(time=t+30)) + val released=heldHand(t+10).copy(trigger=0f,grip=false) + s.setHands(7,released,released) + val late=s.hand(0,t+30) + assertTrue(late.valid);assertFalse(late.triggerValid);assertFalse(late.gripValid) + assertEquals(listOf(1,1,1,1),epochs(s)) + s.setHands(7,released.copy(timeNs=t+40),released.copy(timeNs=t+40)) + assertTrue(s.hand(0,t+40).triggerValid);assertTrue(s.hand(0,t+40).gripValid) + assertEquals(listOf(1,1,1,1),epochs(s)) + } + @Test fun freshReplacementAfterLongHandGapStillAdvancesResetEpoch() { + val s=session();s.setHands(7,heldHand(),heldHand()) + for(i in 1..5) s.accept(sample(time=t+i*50_000_000)) + s.setHands(7,heldHand(t+250_000_000),heldHand(t+250_000_000)) + assertTrue(s.hand(0,t+250_000_000).valid) + assertEquals(listOf(1,1,1,1),epochs(s)) + } + @Test fun handExpiryAndRepeatedInvalidPollsOnlyIncrementOnce() { + val s=session();s.setHands(7,heldHand(),SpatialHand()) + for(i in 1..4) s.accept(sample(time=t+i*50_000_000)) + assertTrue(s.hand(0,t+200_000_000).valid) + repeat(4) { assertFalse(s.hand(0,t+200_000_001+it).valid) } + assertEquals(listOf(1,1,0,0),epochs(s)) + s.setHands(7,heldHand(t+210_000_000),SpatialHand()) + assertTrue(s.hand(0,t+210_000_000).valid) + assertEquals(listOf(1,1,0,0),epochs(s)) + } + @Test fun headExpiryThenDelayedHeadSampleDoesNotDoubleCountLoss() { + val s=session();s.setHands(7,heldHand(),heldHand()) + for(i in 0..1) assertFalse(s.hand(i,t+100_000_001).valid) + assertEquals(listOf(1,1,1,1),epochs(s)) + s.accept(sample(time=t+150_000_000)) + s.setHands(7,heldHand(t+160_000_000),heldHand(t+160_000_000)) + assertEquals(listOf(1,1,1,1),epochs(s)) + } + @Test fun disabledHandsReleaseOnceAndWrongGenerationDoesNotAffectCurrentHands() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.setHands(6,SpatialHand(),SpatialHand()) + assertTrue(s.hand(0,t).valid);assertEquals(listOf(0,0,0,0),epochs(s)) + repeat(3) { s.setHands(7,SpatialHand(),SpatialHand()) } + assertEquals(listOf(1,1,1,1),epochs(s)) + s.reset(8,1.6f) + assertEquals(0,s.inputEpochs()) + } + @Test fun invalidTriggerValueOnlyInvalidatesItsOwnGestureEpoch() { + val s=session();s.setHands(7,heldHand(),heldHand()) + s.setHands(7,heldHand(t+10).copy(trigger=Float.NaN),heldHand(t+10)) + assertEquals(listOf(1,0,0,0),epochs(s)) + assertFalse(s.hand(0,t+10).triggerValid);assertTrue(s.hand(0,t+10).gripValid) + } + @Test fun eachPackedEpochWrapsWithinItsOwnByte() { + val s=session() + repeat(255) { + s.setHands(7,heldHand(t+it*2),heldHand(t+it*2)) + s.setHands(7,SpatialHand(),SpatialHand()) + } + assertEquals(listOf(255,255,255,255),epochs(s));assertEquals(-1,s.inputEpochs()) + s.setHands(7,heldHand(t+512),heldHand(t+512));s.setHands(7,SpatialHand(),SpatialHand()) + assertEquals(0,s.inputEpochs()) + } + @Test fun historyNeverCrossesReconnectOrLargeTimeGap() { + val s=session();assertNotNull(s.poseAt(t+4_000_000,7));assertNull(s.poseAt(t+20_000_000,7)) + s.reset(8,1.6f);assertNull(s.poseAt(t,7)) + } + @Test fun cameraClockWarmsUpAndRejectsResetAndJitter() { + val clock=CameraClock();val offset=10_000_000_000L + for(i in 1..15) assertNull(clock.map(i*40_000_000L,offset+i*40_000_000L)) + assertEquals(offset+640_000_000L,clock.map(640_000_000L,offset+640_000_000L)) + assertNull(clock.map(1,offset+1)) + val bad=CameraClock() + for(i in 1..30) assertNull(bad.map(i*40_000_000L,offset+i*40_000_000L+(i%2)*30_000_000L)) + } + @Test fun halfRateCameraClockRetainsSourceTimeThroughSkippedPairs() { + val clock=CameraClock();val offset=10_000_000_000L + for(i in 1..15) assertNull(clock.map(i*80_000_000L,offset+i*80_000_000L)) + assertEquals(offset+1_280_000_000L,clock.map(1_280_000_000L,offset+1_280_000_000L)) + assertEquals(offset+1_440_000_000L,clock.map(1_440_000_000L,offset+1_440_000_000L)) + assertNull(clock.map(1,offset+1)) + } + @Test fun cameraClockKeepsAlignedMappingAfterLongSkippedGaps() { + val offset=10_000_000_000L + for(gap in listOf(240_000_000L,1_000_000_000L)) { + val clock=CameraClock() + for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L) + val source=1_280_000_000L+gap + assertEquals(offset+source,clock.map(source,offset+source)) + assertEquals(offset+source+80_000_000L,clock.map(source+80_000_000L,offset+source+80_000_000L)) + } + } + @Test fun cameraClockRewarmsAfterSourceOrReceiptStopsOrReverses() { + val offset=10_000_000_000L;val end=1_280_000_000L + val resets=listOf(1L to offset+end+80_000_000L, + end to offset+end+80_000_000L, + end+80_000_000L to 1L, + end+80_000_000L to offset+end) + for((source,receipt) in resets) { + val clock=CameraClock() + for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L) + for(i in 0..14) assertNull(clock.map(source+i*80_000_000L,receipt+i*80_000_000L)) + assertEquals(receipt+1_200_000_000L,clock.map(source+1_200_000_000L,receipt+1_200_000_000L)) + } + } + @Test fun cameraClockRewarmsAfterOffsetJumpAcrossSkippedFrames() { + val offset=10_000_000_000L + for(gap in listOf(240_000_000L,1_000_000_000L)) for(jump in listOf(-20_000_001L,20_000_001L)) { + val clock=CameraClock() + for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L) + val source=1_280_000_000L+gap;val receipt=source+offset+jump + for(i in 0..14) assertNull(clock.map(source+i*80_000_000L,receipt+i*80_000_000L)) + assertEquals(receipt+1_200_000_000L,clock.map(source+1_200_000_000L,receipt+1_200_000_000L)) + } + } + @Test fun cameraClockRetainsMappingWithBoundedJitterAcrossSkippedFrames() { + val clock=CameraClock();val offset=10_000_000_000L + for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L+(i%2)*20_000_000L) + assertEquals(offset+1_520_000_000L,clock.map(1_520_000_000L,offset+1_540_000_000L)) + assertEquals(offset+2_520_000_000L,clock.map(2_520_000_000L,offset+2_520_000_000L)) + assertNull(clock.map(2_760_000_000L,offset+2_780_000_001L)) + } + @Test fun cameraClockRetainsMappingThroughIsolatedShortGapReceiptJitter() { + val clock=CameraClock();val offset=10_000_000_000L + for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L) + assertEquals(offset+1_360_000_000L,clock.map(1_360_000_000L,offset+1_390_000_000L)) + assertEquals(offset+1_440_000_000L,clock.map(1_440_000_000L,offset+1_440_000_000L)) + } + @Test fun cameraClockInvalidTimestampRequiresFreshWarmup() { + val offset=10_000_000_000L + for((source,receipt) in listOf(0L to offset,-1L to offset,1L to 0L,1L to -1L)) { + val clock=CameraClock() + for(i in 1..16) clock.map(i*80_000_000L,offset+i*80_000_000L) + assertNull(clock.map(source,receipt)) + for(i in 17..31) assertNull(clock.map(i*80_000_000L,offset+i*80_000_000L)) + assertEquals(offset+2_560_000_000L,clock.map(2_560_000_000L,offset+2_560_000_000L)) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/SteamVrSpatialGateTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/SteamVrSpatialGateTest.kt new file mode 100644 index 0000000000..e626912f87 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/SteamVrSpatialGateTest.kt @@ -0,0 +1,68 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class SteamVrSpatialGateTest { + @Test fun launchWaitsForRunningThenTheEntireSettleInterval() { + val gate = SteamVrSpatialGate() + assertTrue(gate.spatialEnabled(true, 0)) + gate.prepare() + assertFalse(gate.spatialEnabled(true, 60_000)) + gate.setRunning(false, 60_000) + assertFalse(gate.spatialEnabled(true, 60_000)) + gate.setRunning(true, 60_000) + assertFalse(gate.spatialEnabled(true, 61_999)) + assertTrue(gate.spatialEnabled(true, 62_000)) + assertFalse(gate.spatialEnabled(false, 62_000)) + } + + @Test fun repeatedRunningAndActivityPreparationDoNotMoveTheDeadline() { + val gate = SteamVrSpatialGate() + gate.prepare() + gate.setRunning(true, 100) + gate.prepare() + gate.setRunning(true, 1_900) + assertEquals(2_100L, gate.deadline) + assertTrue(gate.spatialEnabled(true, 2_100)) + gate.prepare() + gate.setRunning(true, 10_000) + assertTrue(gate.spatialEnabled(true, 10_000)) + } + + @Test fun explicitCancelRestoresSavedTrackingBeforeRunningAndDuringSettling() { + val gate = SteamVrSpatialGate() + gate.prepare() + gate.cancel() + assertTrue(gate.spatialEnabled(true, 100)) + assertFalse(gate.spatialEnabled(false, 100)) + gate.prepare() + gate.setRunning(true, 200) + gate.cancel() + assertNull(gate.deadline) + assertTrue(gate.spatialEnabled(true, 201)) + assertFalse(gate.spatialEnabled(false, 10_000)) + } + + @Test fun stopAndNewLaunchCannotReuseAnEarlierDeadline() { + val gate = SteamVrSpatialGate() + gate.prepare() + gate.setRunning(true, 100) + gate.setRunning(false, 200) + assertTrue(gate.spatialEnabled(true, 200)) + gate.prepare() + assertFalse(gate.spatialEnabled(true, 2_100)) + gate.setRunning(false, 2_100) + assertFalse(gate.spatialEnabled(true, 2_100)) + gate.setRunning(true, 3_000) + assertFalse(gate.spatialEnabled(true, 4_999)) + assertTrue(gate.spatialEnabled(true, 5_000)) + } + + @Test fun discoveringAnAlreadyRunningSessionStillAllowsSettling() { + val gate = SteamVrSpatialGate() + gate.setRunning(true, 100) + assertFalse(gate.spatialEnabled(true, 2_099)) + assertTrue(gate.spatialEnabled(true, 2_100)) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/StereoCalibrationProfileTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/StereoCalibrationProfileTest.kt new file mode 100644 index 0000000000..e61fde8258 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/StereoCalibrationProfileTest.kt @@ -0,0 +1,89 @@ +package com.droiddeck.launcher.glasses + +import org.json.JSONObject +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28]) +class StereoCalibrationProfileTest { + private fun base() = RuntimeEnvironment.getApplication().assets.open(StereoCalibrationProfile.BASE_ASSET) + .bufferedReader().use { it.readText() } + private fun device(verified: Boolean = true) = JSONObject(base()).put("identity", "my-glasses") + .put("verified", verified).toString() + private fun select(saved: String? = null, identity: String? = "my-glasses", width: Int = 640, height: Int = 480) = + StereoCalibrationProfile.select(saved, ::base, identity, width, height) + + @Test fun newGlassesUseSharedGeometryWithoutClaimingIndividualValidation() { + val profile = select()!! + assertEquals("my-glasses", profile.identity) + assertTrue(profile.bundledBase) + assertFalse(profile.verified) + assertEquals(1.1209395390660726, profile.error, 0.0) + assertEquals(226.0499636040297, profile.matrices[0].values[0], 0.0) + assertEquals(-0.05607918f, profile.cameraToHead.position.x, 0f) + } + + @Test fun unknownSerialCanUseTheModelBase() { + val profile = select(identity = null)!! + assertEquals(StereoCalibrationProfile.BASE_IDENTITY, profile.identity) + assertTrue(profile.bundledBase) + assertFalse(profile.verified) + } + + @Test fun savedDeviceProfileWinsWithoutReadingTheAsset() { + val profile = StereoCalibrationProfile.select(device(), { error("Base must not be read") }, "my-glasses", 640, 480)!! + assertFalse(profile.bundledBase) + assertTrue(profile.verified) + } + + @Test fun unfinishedPersonalCalibrationStillRequiresDistanceValidation() { + val profile = select(device(verified = false))!! + assertFalse(profile.bundledBase) + assertFalse(profile.verified) + } + + @Test fun foreignOrCorruptDeviceProfileFallsBackToBase() { + assertTrue(select(JSONObject(device()).put("identity", "other-glasses").toString())!!.bundledBase) + assertTrue(select("not json")!!.bundledBase) + } + + @Test fun otherCameraGeometryDoesNotUseTheBase() { + assertNull(select(width = 1280, height = 960)) + assertNull(select(width = 480, height = 640)) + } + + @Test fun baseRequiresTheCorrectModelAndCameraPair() { + for ((key, value) in listOf("deviceModel" to "VITURE Luma Pro", "cameraPair" to "left1-right1", "identity" to "device-serial")) { + val text = JSONObject(base()).put(key, value).toString() + assertNull(StereoCalibrationProfile.select(null, { text }, "my-glasses", 640, 480)) + } + } + + @Test fun badLensDimensionsAndInvalidFitsAreRejectedBeforeNativeAllocation() { + for (name in listOf("k1", "d1", "k2", "d2", "r", "t")) { + val data = JSONObject(base()) + data.getJSONObject(name).put("rows", 2) + assertNull(StereoCalibrationProfile.parse(data.toString(), StereoCalibrationProfile.BASE_IDENTITY, 640, 480, true)) + } + for (error in listOf(-1.0, 2.01)) { + val data = JSONObject(base()).put("error", error) + assertNull(StereoCalibrationProfile.parse(data.toString(), StereoCalibrationProfile.BASE_IDENTITY, 640, 480, true)) + } + } + + @Test fun missingAssetAndNoDeviceProfileRequiresCalibration() { + assertNull(StereoCalibrationProfile.select(null, { null }, "my-glasses", 640, 480)) + } + + @Test fun shippedBaseContainsNoSourceSerialOrFalseValidationClaim() { + val data = JSONObject(base()) + assertEquals(StereoCalibrationProfile.BASE_IDENTITY, data.getString("identity")) + assertFalse(data.getBoolean("verified")) + assertTrue(data.getJSONObject("sourceValidation").getBoolean("sourceDeviceVerified")) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/StereoFingerGesturesTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/StereoFingerGesturesTest.kt new file mode 100644 index 0000000000..3d33e40eab --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/StereoFingerGesturesTest.kt @@ -0,0 +1,87 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test +import kotlin.math.cos +import kotlin.math.sin + +class StereoFingerGesturesTest { + private fun open(): MutableList { + val p=MutableList(21) { SpatialVector(320f,240f) } + p[4]=SpatialVector(390f,190f) + for((base,x) in listOf(5 to 355f,9 to 330f,13 to 305f,17 to 280f)) { + for(j in 0..3) p[base+j]=SpatialVector(x,180f-25f*j) + } + return p + } + private fun curl(p: MutableList,reach: Float=1f) = p.apply { + for(base in listOf(9,13,17)) this[base+3]=this[0]+(this[base]-this[0])*reach + } + private fun transform(p: List,angle: Float,scale: Float,mirror: Boolean) = p.map { + val x=(if(mirror) -it.x else it.x)*scale + val y=it.y*scale + SpatialVector(x*cos(angle)-y*sin(angle)+700f,x*sin(angle)+y*cos(angle)-80f) + } + @Test fun openingAndClosingAreIndependentOfImageScaleRotationAndHandedness() { + for(mirror in listOf(false,true)) for(angle in listOf(0f,.7f,2.8f)) { + val closed=curl(open()).apply { this[4]=this[8] } + val result=StereoFingerGestures.estimate(transform(closed,angle,1.5f,mirror), + transform(closed,angle+.12f,.7f,mirror),false) + assertTrue(result.gripValid);assertTrue(result.grip) + assertTrue(result.triggerValid);assertEquals(1f,result.trigger,0f) + val released=StereoFingerGestures.estimate(transform(open(),angle,1.5f,mirror), + transform(open(),angle+.12f,.7f,mirror),true) + assertTrue(released.gripValid);assertFalse(released.grip) + assertTrue(released.triggerValid);assertEquals(0f,released.trigger,0f) + } + } + @Test fun curlThresholdsProvideObservedHysteresisAndRelease() { + val partial=curl(open(),1.4f) + val idle=StereoFingerGestures.estimate(partial,partial,false) + val held=StereoFingerGestures.estimate(partial,partial,true) + assertTrue(idle.gripValid);assertFalse(idle.grip) + assertTrue(held.gripValid);assertTrue(held.grip) + val opening=curl(open(),1.6f) + assertFalse(StereoFingerGestures.estimate(opening,opening,true).grip) + val two=curl(open()).apply { for(i in 17..20) this[i]=open()[i] } + assertFalse(StereoFingerGestures.estimate(two,two,false).grip) + assertTrue(StereoFingerGestures.estimate(two,two,true).grip) + } + @Test fun shortStraightProjectedFingersDoNotCountAsCurled() { + val straight=open().apply { + for(base in listOf(9,13,17)) for(j in 1..3) this[base+j]=this[base]+SpatialVector(y=-4.5f*j) + } + val result=StereoFingerGestures.estimate(straight,straight,false) + assertTrue(result.gripValid);assertFalse(result.grip) + } + @Test fun pinchRequiresBothEyesAndUsesTheirMoreOpenEstimate() { + fun pinch(ratio: Float)=open().apply { this[4]=this[8]+SpatialVector(x=75f*ratio) } + val result=StereoFingerGestures.estimate(pinch(.25f),pinch(.30f),false) + assertTrue(result.triggerValid);assertEquals((.55f-.30f)/.35f,result.trigger,.0001f) + val conflict=StereoFingerGestures.estimate(pinch(.25f),pinch(.50f),false) + assertFalse(conflict.triggerValid);assertEquals(0f,conflict.trigger,0f) + assertTrue(conflict.gripValid);assertFalse(conflict.grip) + } + @Test fun conflictingCurlDoesNotReportAnObservedRelease() { + val result=StereoFingerGestures.estimate(curl(open()),open(),true) + assertFalse(result.gripValid);assertFalse(result.grip) + assertTrue(result.triggerValid) + } + @Test fun invalidJointsOnlyInvalidateTheirOwnGesture() { + val badPinch=open().apply { this[4]=SpatialVector(Float.NaN,190f) } + val pinch=StereoFingerGestures.estimate(badPinch,open(),false) + assertFalse(pinch.triggerValid);assertTrue(pinch.gripValid) + val badGrip=open().apply { this[15]=SpatialVector(300f,Float.POSITIVE_INFINITY) } + val grip=StereoFingerGestures.estimate(open(),badGrip,true) + assertTrue(grip.triggerValid);assertFalse(grip.gripValid);assertFalse(grip.grip) + } + @Test fun missingViewsAndDegeneratePalmsCannotArmInputs() { + val flat=open().apply { for(i in listOf(0,5,9,13,17)) this[i]=SpatialVector(i.toFloat(),0f) } + val collapsed=open().apply { this[17]=this[5] } + for(invalid in listOf(null,emptyList(),flat,collapsed)) { + val result=StereoFingerGestures.estimate(open(),invalid,true) + assertFalse(result.triggerValid);assertFalse(result.gripValid) + assertEquals(0f,result.trigger,0f);assertFalse(result.grip) + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/StereoInferenceRunnerTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/StereoInferenceRunnerTest.kt new file mode 100644 index 0000000000..c100c548b1 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/StereoInferenceRunnerTest.kt @@ -0,0 +1,72 @@ +package com.droiddeck.launcher.glasses + +import java.util.concurrent.CountDownLatch +import java.util.concurrent.Executors +import java.util.concurrent.TimeUnit +import org.junit.Assert.* +import org.junit.Test + +class StereoInferenceRunnerTest { + @Test fun camerasRunConcurrentlyAndRightDetectorKeepsItsOwnerThread() { + StereoInferenceRunner().use { runner -> + val owner=runner.onRight { Thread.currentThread() } + val rightStarted=CountDownLatch(1) + val leftStarted=CountDownLatch(1) + val pair=runner.pair({ + leftStarted.countDown() + assertTrue(rightStarted.await(2,TimeUnit.SECONDS)) + 1 + }, { + rightStarted.countDown() + assertTrue(leftStarted.await(2,TimeUnit.SECONDS)) + assertSame(owner,Thread.currentThread()) + 2 + }) + assertEquals(1 to 2,pair) + assertSame(owner,runner.onRight { Thread.currentThread() }) + } + } + + @Test fun leftFailureDoesNotReleasePixelsWhileRightStillUsesThem() { + StereoInferenceRunner().use { runner -> + val finished=CountDownLatch(1) + val failure=IllegalStateException("left") + try { + runner.pair({ throw failure }, { Thread.sleep(25);finished.countDown();1 }) + fail("Expected inference failure") + } catch(e: IllegalStateException) { assertSame(failure,e) } + assertEquals(0L,finished.count) + } + } + + @Test fun rightFailureReachesOwnerAndWorkerCanStillCloseDetector() { + StereoInferenceRunner().use { runner -> + val failure=IllegalStateException("right") + try { + runner.pair({ 1 }, { throw failure }) + fail("Expected inference failure") + } catch(e: IllegalStateException) { assertSame(failure,e) } + assertTrue(runner.onRight { true }) + } + } + + @Test fun shutdownInterruptionWaitsForInferenceBeforeReturningBuffers() { + StereoInferenceRunner().use { runner -> + val owner=Executors.newSingleThreadExecutor() + val running=CountDownLatch(1);val release=CountDownLatch(1) + try { + val result=owner.submit { + Thread.currentThread().interrupt() + assertEquals(1 to 2,runner.pair({ 1 }, { + running.countDown();check(release.await(2,TimeUnit.SECONDS));2 + })) + Thread.interrupted() + } + assertTrue(running.await(2,TimeUnit.SECONDS)) + assertFalse(result.isDone) + release.countDown() + assertTrue(result.get(2,TimeUnit.SECONDS)) + } finally { release.countDown();owner.shutdownNow() } + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/StereoPointValidationTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/StereoPointValidationTest.kt new file mode 100644 index 0000000000..0cb263b5ed --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/StereoPointValidationTest.kt @@ -0,0 +1,30 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class StereoPointValidationTest { + private val p1=doubleArrayOf(400.0,0.0,320.0,0.0, 0.0,400.0,240.0,0.0, 0.0,0.0,1.0,0.0) + private val p2=p1.copyOf().apply { this[3]=-24.0 } + private val point=doubleArrayOf(0.0,0.0,.5,1.0) + private val left=doubleArrayOf(320.0,240.0) + private val right=doubleArrayOf(272.0,240.0) + @Test fun metricDepthAndReprojectionThresholdAreUnchanged() { + val result=StereoPointValidation.reconstruct(point,left,right,p1,p2)!! + assertEquals(.5f,result.z,0f) + assertNotNull(StereoPointValidation.reconstruct(point,left,doubleArrayOf(275.0,240.0),p1,p2)) + assertNull(StereoPointValidation.reconstruct(point,left,doubleArrayOf(275.01,240.0),p1,p2)) + } + @Test fun aRejectedLandmarkDoesNotRemoveItsValidNeighbors() { + val observations=listOf(left,doubleArrayOf(Double.NaN,240.0),left) + val points=observations.map { StereoPointValidation.reconstruct(point,it,right,p1,p2) } + assertNotNull(points[0]);assertNull(points[1]);assertNotNull(points[2]) + } + @Test fun invalidDepthAndProjectionNeverProduceValidPoints() { + for(z in listOf(-.5,.149,1.501,Double.NaN,Double.POSITIVE_INFINITY)) + assertNull(StereoPointValidation.reconstruct(doubleArrayOf(0.0,0.0,z,1.0),left,right,p1,p2)) + assertNull(StereoPointValidation.reconstruct(point.copyOf().apply { this[3]=0.0 },left,right,p1,p2)) + assertNull(StereoPointValidation.reconstruct(point,left,right,p1,p2.copyOf().apply { this[10]=-1.0 })) + assertNull(StereoPointValidation.reconstruct(point,left,right,p1,p2.copyOf().apply { this[0]=Double.NaN })) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/TrackingRecoveryTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/TrackingRecoveryTest.kt new file mode 100644 index 0000000000..178438fac6 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/TrackingRecoveryTest.kt @@ -0,0 +1,46 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.* +import org.junit.Test + +class TrackingRecoveryTest { + @Test fun periodicStatusRefreshDetectsExpiryWithoutAnotherPoseCallback() { + val time=1_000_000_000L + val session=SpatialTracking.session + try { + session.reset(91,1.6f) + session.accept(SpatialSample(SpatialPose(),time,91,true)) + SpatialTracking.refreshStatus(time) + assertTrue(SpatialTracking.status.value.headFresh) + assertNull(TrackingRecovery.forSession(true,true,SpatialTracking.status.value)) + SpatialTracking.refreshStatus(time+100_000_001) + assertFalse(SpatialTracking.status.value.headFresh) + assertEquals(TrackingRecovery.LOST,TrackingRecovery.forSession(true,true,SpatialTracking.status.value)) + session.accept(SpatialSample(SpatialPose(),time+110_000_000,91,true)) + SpatialTracking.refreshStatus(time+110_000_000) + assertNull(TrackingRecovery.forSession(true,true,SpatialTracking.status.value)) + } finally { + session.reset(92,1.6f) + SpatialTracking.refreshStatus(time+200_000_000) + } + } + + @Test fun healthyAndNonSpatialSessionsNeverShowRecovery() { + assertNull(TrackingRecovery.forSession(true,true,SpatialTrackingStatus(trackingValid=true,headFresh=true))) + assertNull(TrackingRecovery.forSession(false,false,SpatialTrackingStatus())) + assertEquals(TrackingRecovery.DISCONNECTED,TrackingRecovery.forSession(true,false,SpatialTrackingStatus(trackingValid=true))) + } + + @Test fun pendingRecenterStillRequiresLookingAroundUntilHeadTrackingReturns() { + val pending=SpatialTrackingStatus(recenterPending=true,needsRecenter=true) + assertEquals(TrackingRecovery.LOST,TrackingRecovery.forSession(true,true,pending)) + assertEquals(TrackingRecovery.STABILIZING,TrackingRecovery.forSession(true,true,pending.copy(headFresh=true))) + assertNull(TrackingRecovery.forSession(true,true,pending.copy(headFresh=true,trackingValid=true,recenterPending=false,needsRecenter=false))) + } + + @Test fun newTrackingFrameExplainsTheRequiredRecenter() { + val changed=SpatialTrackingStatus(needsRecenter=true,headFresh=true) + assertEquals(TrackingRecovery.RECENTER,TrackingRecovery.forSession(true,true,changed)) + assertEquals(TrackingRecovery.LOST,TrackingRecovery.forSession(true,true,changed.copy(headFresh=false))) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/UvcStreamHealthTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/UvcStreamHealthTest.kt new file mode 100644 index 0000000000..9dbade47d2 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/glasses/UvcStreamHealthTest.kt @@ -0,0 +1,49 @@ +package com.droiddeck.launcher.glasses + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Test + +class UvcStreamHealthTest { + private fun sample(frames: Long = 901, lastMs: Long = 30990, endMs: Long = 31000, + maximumGapMs: Long = 34) = LongArray(14).apply { + this[6]=lastMs*1_000_000 + this[7]=1_000_000_000 + this[8]=maximumGapMs*1_000_000 + this[9]=frames + this[12]=endMs*1_000_000 + this[13]=(endMs-lastMs)*1_000_000 + } + + @Test fun sustainedStreamMeasuresEntireWindow() { + val health=UvcStreamHealth.assess(sample(),30,30000) + assertTrue(health.healthy) + assertEquals(30000.0,health.observationMs,0.001) + assertEquals(30.0,health.observedFps,0.001) + } + + @Test fun earlyFramesCannotHideLongFinalStall() { + val health=UvcStreamHealth.assess(sample(frames=31,lastMs=2000),30,30000) + assertFalse(health.healthy) + assertEquals(1.0,health.observedFps,0.001) + assertEquals(29000.0,health.maximumGapMs,0.001) + assertFalse(UvcStreamHealth.assess(sample(frames=1,lastMs=1000),30,30000).healthy) + } + + @Test fun frameRateCannotHideInterFrameOrFinalGaps() { + assertFalse(UvcStreamHealth.assess(sample(maximumGapMs=500),30,30000).healthy) + assertFalse(UvcStreamHealth.assess(sample(lastMs=30500),30,30000).healthy) + } + + @Test fun shortObservationAndLowFrameRateAreUnhealthy() { + assertFalse(UvcStreamHealth.assess(sample(frames=31,lastMs=1990,endMs=2000),30,30000).healthy) + assertFalse(UvcStreamHealth.assess(sample(frames=601),30,30000).healthy) + assertFalse(UvcStreamHealth.assess(sample().apply { this[4]=-1 },30,30000).healthy) + } + + @Test fun lowFrameRateAllowsThreeFramePeriods() { + assertTrue(UvcStreamHealth.assess(sample(frames=151,lastMs=30600,maximumGapMs=400),5,30000).healthy) + assertFalse(UvcStreamHealth.assess(sample(frames=151,lastMs=30300,maximumGapMs=700),5,30000).healthy) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/glasses/VitureSdkTest.kt b/app/src/test/java/com/droiddeck/launcher/glasses/VitureSdkTest.kt index 3143cf70fe..0bc140777e 100644 --- a/app/src/test/java/com/droiddeck/launcher/glasses/VitureSdkTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/glasses/VitureSdkTest.kt @@ -6,6 +6,16 @@ import kotlin.math.sqrt import com.droiddeck.launcher.gpu.HeadPose class VitureSdkTest { + @Test fun spatialIdentityUsesTheFullSdkDigestAndRejectsMissingValues() { + assertNull(VitureSpatialIdentity.fromSerialHash(null)) + assertNull(VitureSpatialIdentity.fromSerialHash(ByteArray(32))) + assertNull(VitureSpatialIdentity.fromSerialHash(ByteArray(31) { 1 })) + val digest=ByteArray(32) { it.toByte() } + val id=VitureSpatialIdentity.fromSerialHash(digest) + assertEquals("viture:sn-sha256:000102030405060708090a0b0c0d0e0f101112131415161718191a1b1c1d1e1f",id) + assertEquals(id,VitureSpatialIdentity.fromSerialHash(digest.copyOf())) + assertNotEquals(id,VitureSpatialIdentity.fromSerialHash(digest.copyOf().also { it[31]=0xff.toByte() })) + } @Test fun pro2UsesItsOwnSdkTransportAndDisplayLimits() { val m = VitureProtocol.sdkModel("Pro 2")!! assertTrue(m.needsSdk) diff --git a/app/src/test/java/com/droiddeck/launcher/gpu/CardboardTest.kt b/app/src/test/java/com/droiddeck/launcher/gpu/CardboardTest.kt index 40646d6b04..27ea94c926 100644 --- a/app/src/test/java/com/droiddeck/launcher/gpu/CardboardTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/gpu/CardboardTest.kt @@ -33,6 +33,8 @@ class CardboardTest { val c = Cardboard(enabled = true, source = Cardboard.SOURCE_SBS, viewer = "none", ipdMm = 70, screenWidthDm = 55, screenDistanceDm = 25, headTracking = false) assertEquals(c, Cardboard.decode(c.encode())) + val flat = c.copy(source = Cardboard.SOURCE_FLAT) + assertEquals(flat, Cardboard.decode(flat.encode())) val wild = Cardboard.decode(JSONObject().put("ipdMm", 500).put("screenWidthDm", -3).put("viewer", "nope").put("source", 7)) assertEquals(80, wild.ipdMm) assertEquals(5, wild.screenWidthDm) @@ -106,6 +108,18 @@ class CardboardTest { assertEquals(-cos(PI / 6).toFloat(), forward[2], eps) } + @Test fun virtualScreenRecenterUsesTheCurrentHeightAndDirection() { + for (pitch in listOf(-30.0, -10.0, 15.0, 35.0)) { + val yaw = matrix(quat(0f, 0f, 1f, 50.0)) + val tilt = HeadPose.multiply(matrix(quat(1f, 0f, 0f, pitch)), matrix(quat(0f, 0f, 1f, 12.0))) + val screen = HeadPose.multiply(HeadPose.multiply(yaw, HeadPose.fromGlasses(0f, 0f, 0f, 1f)), tilt) + val ref = HeadPose.recenter(screen, centerView = true) + assertVec(HeadPose.IDENTITY, HeadPose.relative(ref, screen)) + val lookUp = matrix(quat(1f, 0f, 0f, 20.0)) + assertVec(lookUp, HeadPose.relative(ref, HeadPose.multiply(screen, lookUp))) + } + } + @Test fun turningTheHeadTurnsTheView() { val upright = floatArrayOf(1f, 0f, 0f, 0f, 0f, -1f, 0f, 1f, 0f) val ref = HeadPose.recenter(upright) diff --git a/app/src/test/java/com/droiddeck/launcher/input/JoyConShmTest.kt b/app/src/test/java/com/droiddeck/launcher/input/JoyConShmTest.kt index a96368c918..f5c4b2377a 100644 --- a/app/src/test/java/com/droiddeck/launcher/input/JoyConShmTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/input/JoyConShmTest.kt @@ -66,12 +66,13 @@ class JoyConShmTest { } @Test fun reopeningKeepsTheSequenceMovingForward() { - JoyConShm.open(file) {}!!.write(JoyCon.LEFT, JoyConShm.Hand(connected = true)) + val first = JoyConShm.open(file) {}!! + first.write(JoyCon.LEFT, JoyConShm.Hand(connected = true)) assertEquals(4, read().getInt(8)) - file.outputStream().use { } - assertEquals(0L, file.length()) + first.close() + val previous = read().getInt(8) assertNotNull(JoyConShm.open(file) {}) - assertEquals(2, read().getInt(8)) + assertTrue(read().getInt(8) > previous) java.io.RandomAccessFile(file, "rw").use { it.seek(8); it.write(byteArrayOf(7, 0, 0, 0)) } JoyConShm.open(file) {}!! val after = read().getInt(8) @@ -79,6 +80,14 @@ class JoyConShmTest { assertTrue("$after after a torn write", after > 7) } + @Test fun anEmptyFileStartsANewSequence() { + file.parentFile!!.mkdirs() + file.outputStream().use { } + assertEquals(0L, file.length()) + assertNotNull(JoyConShm.open(file) {}) + assertEquals(2, read().getInt(8)) + } + @Test fun anUnwritableLocationIsReportedAsMissing() { val blocker = File(dir, "blocker").apply { writeText("") } assertNull(JoyConShm.open(File(blocker, JoyConShm.FILE)) {}) diff --git a/app/src/test/java/com/droiddeck/launcher/runtime/LinuxRuntimeLiveFilesTest.kt b/app/src/test/java/com/droiddeck/launcher/runtime/LinuxRuntimeLiveFilesTest.kt new file mode 100644 index 0000000000..baa6011f6d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/runtime/LinuxRuntimeLiveFilesTest.kt @@ -0,0 +1,130 @@ +package com.droiddeck.launcher.runtime + +import android.content.ContextWrapper +import com.droiddeck.launcher.session.SessionPhase +import com.droiddeck.launcher.session.SessionState +import java.io.File +import java.nio.file.Files +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertFalse +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment + +@RunWith(RobolectricTestRunner::class) +class LinuxRuntimeLiveFilesTest { + private val root = Files.createTempDirectory("guest-live-files").toFile() + private val context = object : ContextWrapper(RuntimeEnvironment.getApplication()) { + override fun getFilesDir() = File(root, "files").apply { mkdirs() } + override fun getCacheDir() = File(root, "cache").apply { mkdirs() } + override fun getNoBackupFilesDir() = File(root, "no_backup").apply { mkdirs() } + } + + @Before fun setUp() { + SessionState.running = false + SessionState.phase = SessionPhase.IDLE + } + + @After fun tearDown() { + Thread.interrupted() + SessionState.running = false + SessionState.phase = SessionPhase.IDLE + root.deleteRecursively() + } + + @Test fun cacheEvictionPreservesGuestSharedMemoryAndRuntimeBindings() { + val binds = LinuxRuntime.binds(context, null, null, null, null) + val shm = File(binds.single { it.endsWith(":/dev/shm") }.removeSuffix(":/dev/shm")) + val live = LinuxRuntime.liveDir(context) + val files = listOf(File(shm, "steamvr-ipc"), File(LinuxRuntime.prootTempDir(context), "loader"), + File(live, "drm/device"), File(live, "bwrap/1/state")) + files.forEach { it.parentFile!!.mkdirs(); it.writeText("active") } + val disposable = File(context.cacheDir, "download").apply { writeText("cached") } + + context.cacheDir.deleteRecursively() + + assertFalse(disposable.exists()) + files.forEach { assertEquals("active", it.readText()) } + assertTrue(live.path in binds) + assertEquals(binds, LinuxRuntime.binds(context, null, null, null, null)) + assertTrue(live.toPath().startsWith(context.noBackupFilesDir.toPath())) + } + + @Test fun successfulRemovalClearsGuestScratchAndPreservesOtherNoBackupData() { + val runtime = runtime() + val scratch = scratch() + val unrelated = File(context.noBackupFilesDir, "calibration.json").apply { writeText("preserved") } + + assertTrue(LinuxRuntimeInstaller.beginUninstall(context, runtime)!!.run(null)) + + assertFalse(runtime.exists()) + assertFalse(scratch.exists()) + assertFalse(File(context.noBackupFilesDir, "guest-runtime").exists()) + assertEquals("preserved", unrelated.readText()) + } + + @Test fun failedRuntimeRemovalPreservesGuestScratch() { + val runtime = runtime() + val scratch = scratch() + val cannotMove = object : File(runtime.path) { + override fun renameTo(dest: File) = false + } + + assertFalse(LinuxRuntimeInstaller.beginUninstall(context, cannotMove)!!.run(null)) + + assertTrue(runtime.exists()) + assertEquals("active", scratch.readText()) + } + + @Test fun interruptedRemovalPreservesGuestScratch() { + val runtime = runtime() + val scratch = scratch() + val removal = LinuxRuntimeInstaller.beginUninstall(context, runtime)!! + + Thread.currentThread().interrupt() + try { + assertFalse(removal.run(null)) + } finally { + Thread.interrupted() + } + + assertTrue(runtime.exists()) + assertEquals("active", scratch.readText()) + } + + @Test fun aSessionStartingBeforeTheWorkerRunsPreservesRuntimeAndScratch() { + val runtime = runtime() + val scratch = scratch() + val removal = LinuxRuntimeInstaller.beginUninstall(context, runtime)!! + SessionState.phase = SessionPhase.STARTING_COMPOSITOR + + assertFalse(removal.run(null)) + + assertTrue(runtime.exists()) + assertEquals("active", scratch.readText()) + } + + @Test fun aSessionActiveBeforeScratchCleanupPreservesScratch() { + val runtime = runtime() + val scratch = scratch() + val removal = LinuxRuntimeInstaller.beginUninstall(context, runtime)!! + + assertFalse(removal.run { _, _ -> SessionState.running = true }) + + assertEquals("active", scratch.readText()) + } + + private fun runtime() = LinuxRuntime.rootDir(context).apply { + mkdirs() + File(this, "runtime-file").writeText("installed") + } + + private fun scratch() = File(LinuxRuntime.liveDir(context), "shm/steamvr-ipc").apply { + parentFile!!.mkdirs() + writeText("active") + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/session/FexCatalogTest.kt b/app/src/test/java/com/droiddeck/launcher/session/FexCatalogTest.kt new file mode 100644 index 0000000000..3f4fa2f75d --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/session/FexCatalogTest.kt @@ -0,0 +1,46 @@ +package com.droiddeck.launcher.session + +import org.junit.Assert.assertEquals +import org.junit.Assert.assertNull +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [33]) +class FexCatalogTest { + private val sha = "0fc1ca2ba13817ad70d1ea157119a75c9c02446b57d166e6d676cce0807c19c4" + private val url = "https://github.com/Droid-Deck/DroidDeck-Components/releases/download/fex-2610-r5/fex.tzst" + + private fun json(release: String = "fex-2610-r5", url: String = this.url, sha256: String = sha) = + """{"schemaVersion": 1, "category": "fex", "release": "$release", "url": "$url", "sha256": "$sha256", "size": 4083539}""" + + @Test fun readsTheBuildComponentsNames() { + assertEquals(FexCatalog.Build("fex-2610-r5", url, sha), FexCatalog.parse(json())) + } + + @Test fun readsTheSingleReleaseByItsVersion() { + val single = "https://github.com/Droid-Deck/DroidDeck-Components/releases/download/fex/fex.tzst" + assertEquals(FexCatalog.Build("fex-2610-r6", single, sha), FexCatalog.parse(json(release = "fex", url = single).replace("}", ", \"version\": \"2610-r6\"}"))) + assertNull(FexCatalog.parse(json(release = "fex", url = single).replace("}", ", \"version\": \"latest\"}"))) + assertNull(FexCatalog.parse(json(release = "fex", url = single))) + } + + @Test fun refusesAnArchiveOutsideItsOwnRelease() { + assertNull(FexCatalog.parse(json(url = "https://example.com/fex.tzst"))) + assertNull(FexCatalog.parse(json(url = url.replace("fex-2610-r5/", "fex-2610-r4/")))) + assertNull(FexCatalog.parse(json(release = "latest", url = url.replace("fex-2610-r5", "latest")))) + } + + @Test fun refusesAMissingOrMalformedDigest() { + assertNull(FexCatalog.parse(json(sha256 = "abc"))) + assertNull(FexCatalog.parse("""{"release": "fex-2610-r5", "url": "$url"}""")) + assertNull(FexCatalog.parse("not json")) + } + + @Test fun theSessionGetsTheBuildAndEverySource() { + val env = FexCatalog.environment(FexCatalog.Build("fex-2610-r5", url, sha), listOf(url, "https://ghfast.top/$url")) + assertEquals(listOf("BL_FEX_TAG=fex-2610-r5", "BL_FEX_SHA256=$sha", "BL_FEX_URLS=$url https://ghfast.top/$url"), env) + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/FexVersionTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/FexVersionTest.kt index 8fb2016365..3d4600f8c1 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/FexVersionTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/FexVersionTest.kt @@ -14,6 +14,11 @@ class FexVersionTest { assertNull(fexVersionOf("# FEX_TAG=fex-2610-r3\n")) } + @Test fun readsAnInstalledOrCatalogTag() { + assertEquals("2610 r5", fexVersionOfTag("fex-2610-r5\n")) + assertNull(fexVersionOfTag("latest")) + } + @Test fun theShippedLauncherHasOne() { val script = java.io.File("../tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64").takeIf { it.isFile } ?: java.io.File("tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64") diff --git a/app/src/test/java/com/droiddeck/launcher/ui/GlassesMenuNavigationTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/GlassesMenuNavigationTest.kt new file mode 100644 index 0000000000..7ef5078e05 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/GlassesMenuNavigationTest.kt @@ -0,0 +1,171 @@ +package com.droiddeck.launcher.ui + +import android.view.Display +import androidx.compose.foundation.background +import androidx.compose.foundation.layout.Column +import androidx.compose.foundation.layout.fillMaxSize +import androidx.compose.foundation.layout.fillMaxWidth +import androidx.compose.foundation.layout.padding +import androidx.compose.foundation.rememberScrollState +import androidx.compose.foundation.verticalScroll +import androidx.compose.material3.MaterialTheme +import androidx.compose.runtime.* +import androidx.compose.ui.Modifier +import androidx.compose.ui.focus.FocusRequester +import androidx.compose.ui.focus.focusRequester +import androidx.compose.ui.input.InputMode +import androidx.compose.ui.input.InputModeManager +import androidx.compose.ui.platform.LocalInputModeManager +import androidx.compose.ui.input.key.Key +import androidx.compose.ui.platform.LocalView +import androidx.compose.ui.platform.testTag +import androidx.compose.ui.test.* +import androidx.compose.ui.unit.dp +import com.droiddeck.launcher.glasses.GlassesResolution +import com.droiddeck.launcher.glasses.GlassesSettings +import com.droiddeck.launcher.glasses.GlassesState +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode +import java.io.File + +@OptIn(ExperimentalTestApi::class, androidx.compose.ui.ExperimentalComposeUiApi::class) +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], qualifiers = "w360dp-h800dp") +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class GlassesMenuNavigationTest { + @get:Rule val compose = createRobolectricComposeRule() + private lateinit var view: android.view.View + private lateinit var inputMode: InputModeManager + private val firstTab = FocusRequester() + private val glasses = GlassesState(present = true, connected = true, controllable = true, + displayId = Display.DEFAULT_DISPLAY + 1, model = "VITURE Luma Ultra", width = 1920, height = 1200, + hz = 60f, sbs90 = true, supportsSpatial = true, supportsScreen3dof = true, brightness = 4, volume = 3, + resolutions = listOf(GlassesResolution(1920, 1080), GlassesResolution(1920, 1200))) + + @Test fun narrowMenuSeparatesDisplayVrTrackingAndDevice() { + show(inSession = false) + compose.onNodeWithTag("setting-glasses-resolution-two_d").assertExists() + compose.onNodeWithTag("setting-glasses-resolution-three_d").assertExists() + savePreview("display") + compose.onNodeWithTag("glasses-distance").performScrollTo() + savePreview("virtual-screen") + compose.onNodeWithTag("glasses-tab-vr").assertIsDisplayed().performClick() + compose.onNodeWithTag("setting-glasses-resolution-vr").assertIsDisplayed() + compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist() + compose.onNodeWithTag("glasses-vr-fov").assertExists() + savePreview("vr") + compose.onNodeWithTag("glasses-tab-tracking").performClick() + compose.onNodeWithText("LUMA ULTRA CAMERAS — EXPERIMENTAL").assertExists() + compose.onNodeWithTag("setting-glasses-position").assertExists() + savePreview("tracking") + compose.onNodeWithTag("setting-glasses-hands").performScrollTo().assertIsDisplayed() + compose.onNodeWithTag("setting-glasses-joycons").assertExists() + savePreview("hands") + compose.onNodeWithTag("glasses-tab-hardware").assertIsDisplayed().performClick() + compose.onNodeWithTag("glasses-brightness").assertIsDisplayed() + compose.onNodeWithTag("glasses-volume").assertIsDisplayed() + compose.onNodeWithTag("setting-glasses-sunblock").assertIsDisplayed() + compose.onNodeWithTag("setting-glasses-position").assertDoesNotExist() + savePreview("device") + } + + @Test fun controllerCanReachVrTabAndItsLaunchAction() { + var launches = 0 + show(inSession = true, launch = { launches++ }) + compose.runOnIdle { inputMode.requestInputMode(InputMode.Keyboard); firstTab.requestFocus() } + compose.onNodeWithTag("glasses-tab-display").assertIsFocused().performKeyInput { + pressKey(Key.DirectionRight) + pressKey(Key.Enter) + } + compose.onNodeWithTag("glasses-tab-vr").assertIsSelected() + compose.onNodeWithTag("glasses-tab-vr").performKeyInput { pressKey(Key.DirectionDown) } + compose.onNodeWithText("Start SteamVR").assertIsFocused().performKeyInput { pressKey(Key.Enter) } + assertEquals(1, launches) + savePreview("session-vr") + } + + @Test fun unavailableHardwareDoesNotLeaveEmptyTabs() { + var tabs = emptyList>() + compose.setContent { DroidDeckTheme { tabs = glassesTabs(glasses.copy(connected = false)) } } + compose.runOnIdle { assertEquals(listOf("display", "vr"), tabs.map { it.first }) } + } + + @Test fun threeDofRecenterComesFirstOnEveryTab() { + assertRecenterComesFirst(GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), false) + } + + @Test fun sixDofRecenterComesFirstOnEveryTab() { + assertRecenterComesFirst(GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, positionalTracking = true), false) + } + + @Test fun vrRecenterComesFirstOnEveryTab() { + assertRecenterComesFirst(GlassesSettings(), true) + } + + private fun assertRecenterComesFirst(settings: GlassesSettings, vr: Boolean) { + var recenters = 0 + show(inSession = true, settings = settings, steamVrRunning = vr, recenter = { recenters++ }) + val firstControls = listOf( + GlassesTab.DISPLAY to "setting-glasses-game", + GlassesTab.VR to "setting-glasses-auto3d", + GlassesTab.TRACKING to "setting-glasses-tracking", + GlassesTab.HARDWARE to "glasses-brightness", + ) + for ((tab, control) in firstControls) { + compose.onNodeWithTag("glasses-tab-$tab").performClick() + val button = compose.onNodeWithText("Recenter").assertIsDisplayed() + assertTrue("Recenter must precede $control", button.fetchSemanticsNode().boundsInRoot.bottom <= + compose.onNodeWithTag(control).fetchSemanticsNode().boundsInRoot.top) + button.performClick() + } + assertEquals(4, recenters) + savePreview(if (vr) "recenter-vr" else if (settings.positionalTracking) "recenter-6dof" else "recenter-3dof") + } + + private fun show(inSession: Boolean, launch: () -> Unit = {}, + settings: GlassesSettings = GlassesSettings(positionalTracking = true), + steamVrRunning: Boolean = false, recenter: (() -> Unit)? = null) { + compose.setContent { + DroidDeckTheme { + view = LocalView.current + inputMode = LocalInputModeManager.current + var selected by remember { mutableStateOf(GlassesTab.DISPLAY) } + val host = rememberMenuHost() + Column(Modifier.fillMaxSize().background(MaterialTheme.colorScheme.background).padding(16.dp)) { + SegmentedTabs(glassesTabs(glasses), selected, Modifier.fillMaxWidth(), tabModifier = { key -> + Modifier.testTag("glasses-tab-$key").then(if (key == GlassesTab.DISPLAY) + Modifier.focusRequester(firstTab) else Modifier) + }) { selected = it; host.open = null } + key(selected) { + Column(Modifier.weight(1f).verticalScroll(rememberScrollState())) { + CompositionLocalProvider(LocalChipMinWidth provides 120.dp) { + GlassesGroups(host, glasses, settings, onRecenter = recenter, steamVrRunning = steamVrRunning, + track = { if (it in listOf("glasses-width", "glasses-distance", "glasses-vr-fov", + "glasses-brightness", "glasses-volume")) Modifier.testTag(it) else Modifier }, inSession = inSession, tab = selected, + steamVr = { if (inSession) ActionRow("SteamVR", null, "Start SteamVR", launch) }) + } + } + } + } + } + } + } + + private fun savePreview(name: String) { + val file = File("build/reports/glasses-menus/$name.png") + file.parentFile?.mkdirs() + compose.runOnIdle { + val root = view.rootView + val bitmap = android.graphics.Bitmap.createBitmap(root.width, root.height, android.graphics.Bitmap.Config.ARGB_8888) + root.draw(android.graphics.Canvas(bitmap)) + file.outputStream().use { bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, it) } + bitmap.recycle() + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/GlassesPanelTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/GlassesPanelTest.kt index 1b3ee6f954..701d9d1635 100644 --- a/app/src/test/java/com/droiddeck/launcher/ui/GlassesPanelTest.kt +++ b/app/src/test/java/com/droiddeck/launcher/ui/GlassesPanelTest.kt @@ -6,9 +6,15 @@ import androidx.compose.foundation.rememberScrollState import androidx.compose.foundation.verticalScroll import androidx.compose.ui.Modifier import androidx.compose.ui.platform.testTag +import androidx.compose.ui.semantics.SemanticsProperties +import androidx.compose.ui.test.SemanticsMatcher +import androidx.compose.ui.test.assert import androidx.compose.ui.test.assertIsEnabled +import androidx.compose.ui.test.assertIsNotEnabled import androidx.compose.ui.test.onNodeWithTag import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performScrollTo import com.droiddeck.launcher.R import com.droiddeck.launcher.glasses.GlassesSettings import com.droiddeck.launcher.glasses.GlassesState @@ -24,6 +30,60 @@ import org.robolectric.annotation.Config class GlassesPanelTest { @get:Rule val compose = createRobolectricComposeRule() + @Test fun flatResolutionMenuShowsPerEyeResolutionsBesideRefresh() { + show() + compose.onNodeWithTag("setting-glasses-hz").assertExists() + compose.onNodeWithTag("setting-glasses-resolution-two_d").performScrollTo().performClick() + compose.onNodeWithText("1920 × 1080").assertExists() + compose.onNodeWithText("1920 × 1200").assertExists() + } + + @Test fun stereoResolutionHasItsOwnPreference() { + show(stereo = true) + compose.onNodeWithTag("setting-glasses-resolution-three_d").assertExists() + compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-3d-hz").assertExists() + } + + @Test fun vrResolutionDoesNotEditTheOrdinaryStereoPreference() { + show(stereo = true, steamVrRunning = true, tab = GlassesTab.VR) + compose.onNodeWithTag("setting-glasses-resolution-vr").performScrollTo().performClick() + compose.onNodeWithText("1920 × 1080").assertExists() + compose.onNodeWithTag("setting-glasses-resolution-three_d").assertDoesNotExist() + } + + @Test fun homeDisplayCanConfigureBothOrdinaryResolutionProfiles() { + show(inSession = false) + for (profile in listOf("two_d", "three_d")) + compose.onNodeWithTag("setting-glasses-resolution-$profile").assertExists() + } + + @Test fun nativeThirtyHzAppearsInTheFlatRefreshMenu() { + show(supports30Hz = true) + compose.onNodeWithTag("setting-glasses-hz").performScrollTo().performClick() + compose.onNodeWithText("30 Hz").assertExists() + } + + @Test fun nativeThirtyHzAppearsInStereoEvenWithoutNinetyHzSupport() { + show(stereo = true, supports30Hz = true, sbs90 = false) + compose.onNodeWithTag("setting-glasses-3d-hz").performScrollTo().performClick() + compose.onNodeWithText("30 Hz").assertExists() + compose.onNodeWithText("90 Hz").assertDoesNotExist() + } + + @Test fun unsupportedThirtyHzIsAbsentFromTheRefreshMenu() { + show() + compose.onNodeWithTag("setting-glasses-hz").performScrollTo().performClick() + compose.onNodeWithText("30 Hz").assertDoesNotExist() + } + + @Test fun mirroredNativeThirtyHzExplainsTheDedicatedOutputRequirement() { + show(settings = GlassesSettings(gameOnGlasses = false), supports30Hz = true) + compose.onNodeWithText(text(R.string.glasses_refresh_30_hint)).assertExists() + compose.onNodeWithTag("setting-glasses-hz").performScrollTo().performClick() + compose.onNodeWithText("30 Hz").assertDoesNotExist() + } + @Test fun automaticFlatGameOffersVirtualScreenInsteadOfIneffectiveSliders() { show() compose.onNodeWithTag("glasses-width").assertDoesNotExist() @@ -44,13 +104,13 @@ class GlassesPanelTest { } @Test fun automaticSteamVrShowsFieldOfViewAndStereoRefresh() { - show(stereo = true, steamVrRunning = true) + show(stereo = true, steamVrRunning = true, tab = GlassesTab.VR) compose.onNodeWithTag("glasses-width").assertDoesNotExist() compose.onNodeWithTag("glasses-distance").assertDoesNotExist() compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled() compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist() compose.onNodeWithTag("setting-glasses-3d-hz").assertExists() - compose.onNodeWithText(text(R.string.glasses_screen_direct_hint)).assertExists() + compose.onNodeWithTag("setting-glasses-auto3d").assertExists() } @Test fun mirroredSteamVrIn2dKeepsFieldOfViewAndRecenter() { @@ -63,13 +123,22 @@ class GlassesPanelTest { assertMirroredVrControls() } - @Test fun mirroredSteamVrVirtualScreenKeepsGeometryAndRecenter() { + @Test fun mirroredSteamVrUsesStereoControlsWithASavedVirtualScreen() { show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), steamVrRunning = true, outputActive = false, tab = null) - compose.onNodeWithTag("glasses-width").assertIsEnabled() - compose.onNodeWithTag("glasses-distance").assertIsEnabled() - compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertExists() - compose.onNodeWithText(text(R.string.glasses_screen_no_output)).assertDoesNotExist() + compose.onNodeWithTag("glasses-width").assertDoesNotExist() + compose.onNodeWithTag("glasses-distance").assertDoesNotExist() + compose.onNodeWithText(text(R.string.glasses_screen_direct_hint)).assertExists() + assertMirroredVrControls() + } + + @Test fun automatic3dForVrUsesStereoControlsWithASavedVirtualScreen() { + show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, auto3d = true), + stereo = true, steamVrRunning = true, tab = null) + compose.onNodeWithTag("glasses-width").assertDoesNotExist() + compose.onNodeWithTag("glasses-distance").assertDoesNotExist() + compose.onNodeWithText(text(R.string.glasses_screen_direct_hint)).assertExists() + assertMirroredVrControls() } private fun assertMirroredVrControls() { @@ -78,13 +147,44 @@ class GlassesPanelTest { compose.onNodeWithText(text(R.string.glasses_screen_no_output)).assertDoesNotExist() } - @Test fun automaticStereoOutputWithoutSteamVrUsesVirtualScreenDimensions() { + @Test fun automaticStereoOutputDoesNotEnable3dofOrVirtualScreenDimensions() { show(stereo = true) - compose.onNodeWithTag("glasses-width").assertIsEnabled() - compose.onNodeWithTag("glasses-distance").assertIsEnabled() + compose.onNodeWithTag("setting-glasses-3dof").assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + compose.onNodeWithTag("glasses-width").assertDoesNotExist() + compose.onNodeWithTag("glasses-distance").assertDoesNotExist() compose.onNodeWithTag("glasses-vr-fov").assertDoesNotExist() compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist() compose.onNodeWithTag("setting-glasses-3d-hz").assertExists() + compose.onNodeWithText(text(R.string.glasses_screen_flat_hint)).assertExists() + compose.onNodeWithText(text(R.string.glasses_screen_sbs_hint)).assertDoesNotExist() + } + + @Test fun automaticFlatSbsKeepsTrackingInactive() { + show(stereo = true, tab = GlassesTab.TRACKING) + compose.onNodeWithText(text(R.string.glasses_tracking_flat_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + } + + @Test fun flatGame3dofToggleIsIndependentOfSbsAndShowsScreenControls() { + show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN)) + compose.onNodeWithTag("setting-glasses-3dof").assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on))) + compose.onNodeWithTag("setting-glasses-3d").assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + compose.onNodeWithTag("glasses-width").assertIsEnabled() + compose.onNodeWithTag("glasses-distance").assertIsEnabled() + } + + @Test fun separate3dofToggleIsHiddenWithoutHeadTrackingSupport() { + show(supportsScreen3dof = false) + compose.onNodeWithTag("setting-glasses-3dof").assertDoesNotExist() + } + + @Test fun virtualScreenRecenterExplainsHowToSetTheHeight() { + show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), tab = GlassesTab.TRACKING) + compose.onNodeWithText(text(R.string.glasses_recenter_screen_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertExists() } @Test fun gameWithoutGlassesOutputExplainsWhyGeometryIsUnavailable() { @@ -99,8 +199,8 @@ class GlassesPanelTest { show(inSession = false, outputActive = false) compose.onNodeWithTag("glasses-width").assertIsEnabled() compose.onNodeWithTag("glasses-distance").assertIsEnabled() - compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled() - compose.onNodeWithText(text(R.string.glasses_screen_next_session)).assertExists() + compose.onNodeWithTag("glasses-vr-fov").assertDoesNotExist() + compose.onNodeWithText(text(R.string.glasses_screen_app_wide)).assertExists() } @Test fun flatTrackingExplainsTheModeAndHidesInactiveRecenter() { @@ -116,12 +216,13 @@ class GlassesPanelTest { compose.onNodeWithTag("glasses-distance").assertIsEnabled() compose.onNodeWithTag("setting-glasses-hz").assertDoesNotExist() compose.onNodeWithTag("setting-glasses-3d").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-3dof").assertDoesNotExist() } @Test fun runningSteamVrFieldOfViewRemainsAvailableWhenUsbControlDisconnects() { - show(stereo = true, steamVrRunning = true, controlAvailable = false) + show(stereo = true, steamVrRunning = true, controlAvailable = false, tab = GlassesTab.VR) compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled() - compose.onNodeWithTag("setting-glasses-picture").assertIsEnabled() + compose.onNodeWithTag("setting-glasses-picture").assertDoesNotExist() compose.onNodeWithTag("setting-glasses-3d-hz").assertDoesNotExist() compose.onNodeWithTag("setting-glasses-3d").assertDoesNotExist() } @@ -142,6 +243,152 @@ class GlassesPanelTest { compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() } + @Test fun homeVrCanConfigureResolutionAndFieldOfViewBeforeLaunching() { + show(inSession = false, tab = GlassesTab.VR) + compose.onNodeWithTag("setting-glasses-resolution-vr").assertExists() + compose.onNodeWithTag("glasses-vr-fov").assertIsEnabled() + compose.onNodeWithTag("setting-glasses-auto3d").assertExists() + compose.onNodeWithTag("setting-glasses-picture").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-resolution-two_d").assertDoesNotExist() + } + + @Test fun displayKeepsVrAndHardwareControlsInTheirOwnTabs() { + show(inSession = false) + compose.onNodeWithTag("setting-glasses-auto3d").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-resolution-vr").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-sunblock").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-tracking").assertDoesNotExist() + } + + @Test fun recenterIsHiddenWhenHeadTrackingIsOff() { + show(settings = GlassesSettings(headTracking = false, picture3d = GlassesSettings.PICTURE_SCREEN)) + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + } + + @Test fun trackedMenusCanRecenterWithoutStartingASession() { + var recenters = 0 + show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN), inSession = false, + onRecenter = { recenters++ }) + + compose.onNodeWithText(text(R.string.glasses_recenter_screen_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).performClick() + org.junit.Assert.assertEquals(1, recenters) + } + + @Test fun positionalMenusUseTheSameRecenterAction() { + var recenters = 0 + show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, positionalTracking = true), + supportsSpatial = true, inSession = false, onRecenter = { recenters++ }) + + compose.onNodeWithText(text(R.string.glasses_recenter_screen_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).performClick() + org.junit.Assert.assertEquals(1, recenters) + } + + @Test fun menusWithoutDedicatedGlassesOutputDoNotOfferRecenter() { + show(settings = GlassesSettings(picture3d = GlassesSettings.PICTURE_SCREEN, gameOnGlasses = false), + inSession = false) + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + } + + @Test fun spatialSteamVrIncludesHeadTrackingAndRestoresTheSavedVirtualScreenSwitch() { + val vrRunning = androidx.compose.runtime.mutableStateOf(true) + val saved = GlassesSettings(headTracking = false, positionalTracking = true, + picture3d = GlassesSettings.PICTURE_SCREEN) + show(settings = saved, supportsSpatial = true, tab = GlassesTab.TRACKING, observedSteamVr = vrRunning) + + compose.onNodeWithTag("setting-glasses-tracking").assertIsNotEnabled().assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on))) + compose.onNodeWithText(text(R.string.glasses_head_tracking_spatial_vr_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + + compose.runOnIdle { vrRunning.value = false } + + compose.onNodeWithTag("setting-glasses-tracking").assertIsEnabled().assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + compose.onNodeWithText(text(R.string.glasses_head_tracking_spatial_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + } + + @Test fun rotationOnlySteamVrKeepsTheHeadTrackingSwitchOptional() { + show(settings = GlassesSettings(headTracking = false), supportsSpatial = true, + steamVrRunning = true, tab = GlassesTab.TRACKING) + + compose.onNodeWithTag("setting-glasses-tracking").assertIsEnabled().assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + compose.onNodeWithText(text(R.string.glasses_head_tracking_hint)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + } + + @Test fun spatialPreferencesDoNotClaimHeadTrackingForPhoneOutput() { + val noDisplay = androidx.compose.runtime.mutableStateOf(GlassesState(present = true, + connected = true, controllable = true, supportsSpatial = true)) + show(settings = GlassesSettings(headTracking = false, positionalTracking = true), + steamVrRunning = true, outputActive = false, tab = GlassesTab.TRACKING, observedState = noDisplay) + + compose.onNodeWithTag("setting-glasses-tracking").assertIsEnabled().assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + compose.onNodeWithText(text(R.string.glasses_screen_no_output)).assertExists() + compose.onNodeWithText(text(R.string.cardboard_recenter_button)).assertDoesNotExist() + } + + @Test fun experimentalJoyConsAreOffAndRequirePositionalTracking() { + show(supportsSpatial = true, tab = GlassesTab.TRACKING) + compose.onNodeWithText(text(R.string.glasses_experimental).uppercase()).assertExists() + compose.onNodeWithTag("setting-glasses-joycons").assertIsNotEnabled().assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + } + + @Test fun experimentalGroupFollowsOrdinaryTrackingAndEnablesJoyCons() { + show(supportsSpatial = true, settings = GlassesSettings(positionalTracking = true), tab = GlassesTab.TRACKING) + compose.onNodeWithTag("setting-glasses-joycons").performScrollTo().assertIsEnabled() + val ordinary = compose.onNodeWithTag("setting-glasses-tracking").fetchSemanticsNode().positionInRoot.y + val experimental = compose.onNodeWithText(text(R.string.glasses_experimental).uppercase()).fetchSemanticsNode().positionInRoot.y + org.junit.Assert.assertTrue(experimental > ordinary) + compose.onNodeWithTag("setting-glasses-hands").assertExists() + compose.onNodeWithTag("setting-glasses-steady-hand-aim").assertDoesNotExist() + } + + @Test fun steadyHandAimIsOptionalAndOffByDefault() { + show(supportsSpatial = true, settings = GlassesSettings(positionalTracking = true, handControllers = true), + tab = GlassesTab.TRACKING) + compose.onNodeWithTag("setting-glasses-steady-hand-aim").performScrollTo().assertIsEnabled().assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_off))) + compose.onNodeWithText(text(R.string.glasses_steady_hand_aim_hint)).assertExists() + } + + @Test fun savedSteadyHandAimIsHiddenInJoyConMode() { + show(supportsSpatial = true, settings = GlassesSettings(positionalTracking = true, joyConTracking = true, steadyHandAim = true), + tab = GlassesTab.TRACKING) + compose.onNodeWithTag("setting-glasses-steady-hand-aim").assertDoesNotExist() + } + + @Test fun ultraControlsDisappearOnDisconnectAndForOtherGlassesWithSavedPreferences() { + val state = androidx.compose.runtime.mutableStateOf(GlassesState(present = true, connected = true, + controllable = true, supportsSpatial = true, model = "VITURE Luma Ultra")) + show(settings = GlassesSettings(positionalTracking = true, handControllers = true, joyConTracking = true), + tab = GlassesTab.TRACKING, observedState = state) + compose.onNodeWithTag("setting-glasses-position").assertExists() + compose.onNodeWithTag("setting-glasses-hands").assertExists() + compose.onNodeWithTag("setting-glasses-joycons").assertExists() + val otherStates = listOf(state.value.copy(connected = false)) + + listOf("VITURE Luma Ultra", "VITURE Luma Pro", "VITURE Pro", "XREAL", "RayNeo").map { + state.value.copy(model = it, supportsSpatial = false) + } + for (other in otherStates) { + compose.runOnIdle { state.value = other } + compose.onNodeWithTag("setting-glasses-position").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-hands").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-steady-hand-aim").assertDoesNotExist() + compose.onNodeWithTag("setting-glasses-joycons").assertDoesNotExist() + compose.onNodeWithText(text(R.string.glasses_spatial_setup)).assertDoesNotExist() + compose.onNodeWithText(text(R.string.glasses_eye_height)).assertDoesNotExist() + compose.onNodeWithText(text(R.string.glasses_floor)).assertDoesNotExist() + } + compose.runOnIdle { state.value = state.value.copy(supportsSpatial = true) } + compose.onNodeWithTag("setting-glasses-position").assertExists() + } + private fun show( settings: GlassesSettings = GlassesSettings(), stereo: Boolean = false, @@ -149,23 +396,33 @@ class GlassesPanelTest { inSession: Boolean = true, outputActive: Boolean = inSession, controlAvailable: Boolean = true, + supportsScreen3dof: Boolean = true, + supportsSpatial: Boolean = false, + supports30Hz: Boolean = false, + sbs90: Boolean = true, tab: String? = GlassesTab.DISPLAY, + observedState: androidx.compose.runtime.State? = null, + observedSteamVr: androidx.compose.runtime.State? = null, + onRecenter: (() -> Unit)? = {}, ) { val state = GlassesState(present = true, connected = controlAvailable, controllable = true, displayId = Display.DEFAULT_DISPLAY + 1, width = if (stereo) 3840 else 1920, height = 1200, - model = "VITURE Luma Ultra", sbs = stereo, sbs90 = true) + model = "VITURE Luma Ultra", sbs = stereo, sbs90 = sbs90, supportsScreen3dof = supportsScreen3dof, + supports30Hz = supports30Hz, supportsSpatial = supportsSpatial, resolutions = listOf( + com.droiddeck.launcher.glasses.GlassesResolution(1920, 1080), + com.droiddeck.launcher.glasses.GlassesResolution(1920, 1200))) compose.setContent { DroidDeckTheme { Column(Modifier.verticalScroll(rememberScrollState())) { - GlassesGroups(rememberMenuHost(), state, settings, + GlassesGroups(rememberMenuHost(), observedState?.value ?: state, settings, track = { key -> when (key) { "glasses-width", "glasses-distance", "glasses-vr-fov" -> Modifier.testTag(key) else -> Modifier } - }, onRecenter = {}, + }, onRecenter = onRecenter, inSession = inSession, outputActive = outputActive, - steamVrRunning = steamVrRunning, tab = tab) + steamVrRunning = observedSteamVr?.value ?: steamVrRunning, tab = tab) } } } diff --git a/app/src/test/java/com/droiddeck/launcher/ui/GlobalGlassesSettingsTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/GlobalGlassesSettingsTest.kt new file mode 100644 index 0000000000..b64986a1e4 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/GlobalGlassesSettingsTest.kt @@ -0,0 +1,160 @@ +package com.droiddeck.launcher.ui + +import android.app.Application +import android.content.Context +import android.os.Handler +import android.os.Looper +import androidx.compose.runtime.CompositionLocalProvider +import androidx.compose.ui.semantics.SemanticsProperties +import androidx.compose.ui.test.SemanticsMatcher +import androidx.compose.ui.test.assert +import androidx.compose.ui.test.onNodeWithTag +import androidx.compose.ui.test.onNodeWithText +import androidx.compose.ui.test.performClick +import androidx.compose.ui.test.performScrollTo +import com.droiddeck.launcher.R +import com.droiddeck.launcher.glasses.Glasses +import com.droiddeck.launcher.glasses.GlassesSettings +import com.droiddeck.launcher.glasses.GlassesState +import kotlinx.coroutines.flow.MutableStateFlow +import org.junit.After +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Before +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.Shadows.shadowOf +import org.robolectric.annotation.Config +import org.robolectric.annotation.LooperMode + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], qualifiers = "w1200dp-h752dp-land", application = Application::class) +@LooperMode(LooperMode.Mode.PAUSED) +class GlobalGlassesSettingsTest { + @get:Rule val compose = createRobolectricComposeRule() + private val handler = Handler(Looper.getMainLooper()) + private val connected = GlassesState(present = true, connected = true, controllable = true, + displayId = 2, width = 1920, height = 1080, model = "VITURE Luma Ultra", + supportsScreen3dof = true, supportsSpatial = true) + private lateinit var stateBefore: GlassesState + private lateinit var settingsBefore: GlassesSettings + private var appBefore: Any? = null + private var handlerBefore: Any? = null + + @Before fun prepare() { + stateBefore = Glasses.state.value + settingsBefore = Glasses.settings.value + appBefore = field("app").get(null) + handlerBefore = field("handler").get(null) + val app = RuntimeEnvironment.getApplication() + app.getSharedPreferences("glasses", Context.MODE_PRIVATE).edit().clear().commit() + field("app").set(null, app) + field("handler").set(null, handler) + state().value = GlassesState() + settings().value = GlassesSettings() + } + + @After fun restore() { + handler.removeCallbacksAndMessages(null) + state().value = stateBefore + settings().value = settingsBefore + field("app").set(null, appBefore) + field("handler").set(null, handlerBefore) + } + + @Test fun globalSetupOffersGlassesWithoutSteamOrAnInstalledRuntime() { + show() + openGlasses() + + compose.onNodeWithText(text(R.string.setup_glasses_scope)).assertExists() + compose.onNodeWithText(text(R.string.setup_glasses_connect)).assertExists() + compose.onNodeWithTag("setting-glasses-game").assertDoesNotExist() + compose.onNodeWithTag("play-steamvr").assertDoesNotExist() + + compose.onNodeWithText(text(R.string.setup_tab_diagnostics)).performClick() + compose.onNodeWithTag("setting-logs").assertExists() + openGlasses() + compose.onNodeWithText(text(R.string.setup_glasses_connect)).assertExists() + } + + @Test fun hotplugKeepsTheGlobalPageAndSharedTrackingPreferences() { + val saved = GlassesSettings(positionalTracking = true, handControllers = true) + settings().value = saved + show() + openGlasses() + + compose.runOnIdle { state().value = connected } + compose.onNodeWithTag("setting-glasses-3dof").assertExists() + compose.onNodeWithTag("setup-glasses-tab-tracking").performScrollTo().performClick() + compose.onNodeWithTag("setting-glasses-position").assertExists() + + compose.runOnIdle { state().value = GlassesState() } + compose.onNodeWithText(text(R.string.setup_glasses_connect)).assertExists() + compose.onNodeWithTag("setting-glasses-position").assertDoesNotExist() + assertEquals(saved, Glasses.settings.value) + + compose.runOnIdle { state().value = connected } + compose.onNodeWithTag("setting-glasses-position").assertExists() + compose.onNodeWithTag("setting-glasses-hands").assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on))) + assertEquals(saved, Glasses.settings.value) + } + + @Test fun globalScreenTrackingUsesTheExistingSavedSettings() { + state().value = connected + settings().value = GlassesSettings(gameOnGlasses = false, headTracking = false) + show() + openGlasses() + compose.onNodeWithTag("setting-glasses-3dof").performScrollTo().performClick() + shadowOf(Looper.getMainLooper()).idle() + + assertTrue(Glasses.settings.value.screen3dof) + val prefs = RuntimeEnvironment.getApplication().getSharedPreferences("glasses", Context.MODE_PRIVATE) + assertTrue(prefs.getBoolean("gameOnGlasses", false)) + assertTrue(prefs.getBoolean("headTracking", false)) + assertEquals(GlassesSettings.PICTURE_SCREEN, prefs.getInt("picture3d", -1)) + + compose.onNodeWithText(text(R.string.setup_tab_launcher)).performClick() + openGlasses() + compose.onNodeWithTag("setting-glasses-3dof").assert( + SemanticsMatcher.expectValue(SemanticsProperties.StateDescription, text(R.string.widgets_on))) + } + + private fun openGlasses() { + compose.onNodeWithText(text(R.string.setup_tab_glasses)).performClick() + } + + private fun show() { + compose.setContent { + DroidDeckTheme { + CompositionLocalProvider(LocalFrontFocus provides FrontFocus(), LocalNarrowPane provides false) { + FocusGlideHost { + SetupPanel(FrontEndState( + installed = null, ready = false, available = null, busy = false, stage = "", percent = -1, + desktopInstalled = false, offlineAccount = null, offline = false, frameGenLabel = "", + romsDir = null, logsEnabled = false, steamGames = emptyList(), emulators = emptyList(), running = null, + ), FrontEndActions( + onPlay = {}, onPlayDesktopUi = {}, onSteamGame = {}, onDesktop = {}, onEmulator = {}, + onRom = {}, onResume = {}, onSteamSettings = {}, onDesktopSettings = {}, + onInstallPackage = {}, onRemovePackage = {}, onRuntime = {}, onFrameGenPick = {}, + onImportLossless = {}, onProtons = {}, onComponents = {}, onPerformance = {}, + onRoms = {}, onFiles = {}, onLogs = {}, onOffline = {}, + onWirelessAdbPair = { _, _, _, _ -> }, onWirelessAdbApply = { _, _, _, _ -> }, + onSetPhantomProcessLimit = { _, _ -> }, + ), onOpenDeveloperOptions = {}, onRequestWirelessAdb = {}) + } + } + } + } + } + + private fun text(id: Int) = RuntimeEnvironment.getApplication().getString(id) + private fun field(name: String) = Glasses::class.java.getDeclaredField(name).apply { isAccessible = true } + @Suppress("UNCHECKED_CAST") + private fun state() = field("_state").get(null) as MutableStateFlow + @Suppress("UNCHECKED_CAST") + private fun settings() = field("_settings").get(null) as MutableStateFlow +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/SpatialSetupTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/SpatialSetupTest.kt new file mode 100644 index 0000000000..be609f39e7 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/SpatialSetupTest.kt @@ -0,0 +1,273 @@ +package com.droiddeck.launcher.ui + +import androidx.compose.ui.test.* +import androidx.compose.ui.platform.LocalView +import androidx.compose.runtime.mutableStateOf +import com.droiddeck.launcher.glasses.SpatialCalibrationProgress +import com.droiddeck.launcher.glasses.SpatialTrackingStatus +import com.droiddeck.launcher.glasses.CalibrationDistance +import com.droiddeck.launcher.glasses.CalibrationDistanceCheck +import com.droiddeck.launcher.R +import org.junit.Assert.assertEquals +import org.junit.Assert.assertTrue +import org.junit.Rule +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode +import java.io.File + +@RunWith(RobolectricTestRunner::class) +@Config(sdk = [28], qualifiers = "w411dp-h891dp") +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class SpatialSetupTest { + @get:Rule val compose = createRobolectricComposeRule() + private lateinit var view: android.view.View + + @Test + @Config(qualifiers = "fr-w411dp-h891dp") + fun frenchCalibrationControlsKeepTheSelectedDistanceAndActions() { + val context = RuntimeEnvironment.getApplication() + var selected = 0f + compose.setContent { + DroidDeckTheme { + view = LocalView.current + SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true), + SpatialCalibrationProgress(views = 24, fitted = true), null, "", + SpatialSetupActions(validate = { selected = it })) + } + } + compose.onNodeWithText("Configuration spatiale").assertIsDisplayed() + compose.onNodeWithText("Spatial setup").assertDoesNotExist() + compose.onNodeWithText(context.getString(R.string.spatial_validate)).performScrollTo().performClick() + assertEquals(.3048f, selected, .000001f) + savePreview("calibration-fr") + } + + @Test + @Config(qualifiers = "ar-w411dp-h891dp") + fun arabicCalibrationDiagnosticsUseTranslatedLabelsAndFormatNumbers() { + val context = RuntimeEnvironment.getApplication() + compose.setContent { + DroidDeckTheme { + view = LocalView.current + SpatialSetupScreen(SpatialTrackingStatus(cameraHz = 25f, cameraCopyPermille = 500, frames = 12), + SpatialCalibrationProgress(), null, "", SpatialSetupActions()) + } + } + compose.onNodeWithText(context.getString(R.string.spatial_title)).assertIsDisplayed() + compose.onNodeWithText("Spatial setup").assertDoesNotExist() + compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick() + compose.onNodeWithText(context.getString(R.string.spatial_input_values, 12.5f, 50f)).performScrollTo().assertIsDisplayed() + compose.onNodeWithText("Show diagnostics").assertDoesNotExist() + savePreview("calibration-ar") + } + + @Test fun directLaunchWithoutConnectedUltraClosesBeforeShowingCalibration() { + val field = com.droiddeck.launcher.glasses.Glasses::class.java.getDeclaredField("_state") + .apply { isAccessible = true } + @Suppress("UNCHECKED_CAST") + val state = field.get(null) as kotlinx.coroutines.flow.MutableStateFlow + val previous = state.value + try { + for (candidate in listOf(previous.copy(connected = false, supportsSpatial = true), + previous.copy(connected = true, controllable = true, supportsSpatial = false))) { + state.value = candidate + val activity = org.robolectric.Robolectric.buildActivity(SpatialTrackingActivity::class.java).create() + assertTrue(activity.get().isFinishing) + activity.destroy() + } + } finally { state.value = previous } + } + + @Test fun sharedCalibrationIsUsableWithoutClaimingPerDeviceVerification() { + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(calibration = true, + calibrationSource = "luma-ultra-base", calibrationVerified = false), + SpatialCalibrationProgress(fitted = true), null, "", SpatialSetupActions()) + } + } + compose.onNodeWithText("Shared Luma Ultra calibration").performScrollTo().assertIsDisplayed() + compose.onNodeWithText("Measured calibration verified").assertDoesNotExist() + compose.onNodeWithText("Validation required").assertDoesNotExist() + compose.onNodeWithText("Hand tracking — Experimental").assertExists() + } + + @Test fun pendingRecenterExplainsTheWaitAndBlocksCaptures() { + compose.setContent { + DroidDeckTheme(Themes.ELECTRIC) { + view = LocalView.current + SpatialSetupScreen(SpatialTrackingStatus(message = "Hold still while tracking stabilizes", recenterPending = true), + SpatialCalibrationProgress(collecting = true), null, "", SpatialSetupActions()) + } + } + compose.onNodeWithText("Hold still while tracking stabilizes").assertExists() + compose.onNodeWithText("Waiting for tracking…").assertIsNotEnabled() + savePreview("tracking-recovery") + compose.onNodeWithText("Capture board view").performScrollTo().assertIsNotEnabled() + } + + @Test fun completedFitValidatesTheSelectedImperialOrMetricDistance() { + var distance = 0f + compose.setContent { + DroidDeckTheme { + view = LocalView.current + SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true), + SpatialCalibrationProgress(collecting = true, views = 24, fitted = true), null, "Ready to validate", + SpatialSetupActions(validate = { distance = it })) + } + } + compose.onNodeWithText("Validate distance").performScrollTo().performClick() + assertEquals(0.3048f, distance, 0.000001f) + savePreview("distance-check") + for (choice in CalibrationDistance.entries.drop(1)) { + compose.onNodeWithTag("setting-calibration-distance").performScrollTo().performClick() + compose.onNodeWithText(RuntimeEnvironment.getApplication().getString(choice.labelRes)).performClick() + compose.onNodeWithText("Validate distance").performScrollTo().performClick() + assertEquals(choice.meters, distance, 0.000001f) + } + } + + @Test fun captureRejectionAppearsBesideTheCounter() { + val reason = "Capture rejected: 4 / 12 required corners visible in both cameras." + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true), + SpatialCalibrationProgress(collecting = true, views = 2, captureMessage = reason), null, "", + SpatialSetupActions()) + } + } + compose.onNodeWithText("Capture board view").performScrollTo().assertIsEnabled() + compose.onNodeWithText("2 / 24 views captured").assertIsDisplayed() + compose.onNodeWithText(reason).assertIsDisplayed() + } + + @Test fun pendingCaptureCannotQueueAnotherPress() { + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true), + SpatialCalibrationProgress(collecting = true, capturing = true), null, "", SpatialSetupActions()) + } + } + compose.onNodeWithText("Capturing…").performScrollTo().assertIsNotEnabled() + } + + @Test fun distanceResultAppearsBesideValidationButton() { + val reason=CalibrationDistanceCheck.evaluate(RuntimeEnvironment.getApplication(),.3048f,3,null).message + compose.setContent { + DroidDeckTheme { + view=LocalView.current + SpatialSetupScreen(SpatialTrackingStatus(trackingValid=true,synchronized=true), + SpatialCalibrationProgress(views=25,fitted=true,validationMessage=reason),null, + "Fit 1.12 px. Measure the distance, then validate.",SpatialSetupActions()) + } + } + compose.onNodeWithText("Validate distance").performScrollTo().assertIsEnabled() + compose.onNodeWithText(reason).assertIsDisplayed() + savePreview("distance-result") + } + + @Test fun pendingDistanceCheckShowsFeedbackAndPreventsDuplicateRequests() { + val message="Checking the next camera image. Keep the full board visible and hold still." + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(trackingValid=true,synchronized=true), + SpatialCalibrationProgress(views=25,fitted=true,validating=true,validationMessage=message),null, + "Fit complete",SpatialSetupActions()) + } + } + compose.onNodeWithText("Checking distance…").performScrollTo().assertIsNotEnabled() + compose.onNodeWithText(message).assertIsDisplayed() + } + + @Test fun restoredCapturesCanBeRecalculatedWithoutMixingNewTrackingFrames() { + var solves=0 + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true), + SpatialCalibrationProgress(views = 35, captureMessage = "35 saved views restored."), null, + "Head-to-camera alignment varies by 25 cm (9.84 in).", + SpatialSetupActions(solve = { solves++ })) + } + } + compose.onNodeWithText("Capture board view").performScrollTo().assertIsNotEnabled() + compose.onNodeWithText("35 saved views restored.").assertIsDisplayed() + compose.onNodeWithText("Calculate calibration").performScrollTo().assertIsEnabled().performClick() + assertEquals(1,solves) + } + + @Test + @Config(qualifiers = "w840dp-h360dp-land") + fun landscapeSetupLeavesMostOfTheHeightForScrolling() { + compose.setContent { + DroidDeckTheme { + view = LocalView.current + SpatialSetupScreen(SpatialTrackingStatus(trackingValid = true, synchronized = true), + SpatialCalibrationProgress(views = 35), null, "Ready to calculate", SpatialSetupActions()) + } + } + compose.waitForIdle() + val page=compose.onNodeWithTag("spatial-setup-page").fetchSemanticsNode().boundsInRoot + val viewport=compose.onNode(hasScrollAction()).fetchSemanticsNode().boundsInRoot + assertTrue("Calibration controls need at least 75% of the page height", viewport.height >= page.height*.75f) + savePreview("landscape-compact") + } + + @Test fun diagnosticsSeparateCameraRateFromDeliberatelySkippedFrames() { + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(cameraHz = 25f, cameraFrameDivisor = 2, cameraCopyPermille = 500, + frames = 12, dropped = 3, rateLimitedFrames = 15), + SpatialCalibrationProgress(), null, "", SpatialSetupActions()) + } + } + compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick() + compose.onNodeWithText("Input limit 12.5 Hz • 50% of camera frames. Head tracking stays at full rate.").assertExists() + compose.onNodeWithText("12 processed • 3 dropped • 15 skipped by input limit").assertExists() + compose.onNodeWithText("25.0 Hz", substring = true).assertExists() + } + + @Test fun diagnosticsShowTheAdaptiveFractionInsteadOfTheLegacyDivisor() { + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(cameraHz = 25f, cameraFrameDivisor = 1, cameraCopyPermille = 600), + SpatialCalibrationProgress(), null, "", SpatialSetupActions()) + } + } + compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick() + compose.onNodeWithText("Input limit 15.0 Hz • 60% of camera frames. Head tracking stays at full rate.").assertExists() + } + + @Test fun manualRateControlBecomesAvailableAfterAutomaticRateIsDisabled() { + val automatic=mutableStateOf(true) + val halfRate=mutableStateOf(true) + compose.setContent { + DroidDeckTheme { + SpatialSetupScreen(SpatialTrackingStatus(), SpatialCalibrationProgress(), null, "", + SpatialSetupActions(adaptive = { automatic.value=it }, halfRate = { halfRate.value=it }), + halfRate = halfRate.value, adaptive = automatic.value) + } + } + compose.onNodeWithTag("setting-spatial-diagnostics").performScrollTo().performClick() + compose.onNodeWithTag("setting-spatial-half-rate").assertDoesNotExist() + compose.onNodeWithTag("setting-spatial-adaptive-rate").performScrollTo().performClick() + compose.onNodeWithTag("setting-spatial-half-rate").performScrollTo().performClick() + assertEquals(false,automatic.value) + assertEquals(false,halfRate.value) + } + + private fun savePreview(name: String) { + val file = File("build/reports/spatial-setup/$name.png") + file.parentFile?.mkdirs() + compose.runOnIdle { + val root = view.rootView + val bitmap = android.graphics.Bitmap.createBitmap(root.width, root.height, android.graphics.Bitmap.Config.ARGB_8888) + root.draw(android.graphics.Canvas(bitmap)) + file.outputStream().use { bitmap.compress(android.graphics.Bitmap.CompressFormat.PNG, 100, it) } + bitmap.recycle() + } + } +} diff --git a/app/src/test/java/com/droiddeck/launcher/ui/TrackingRecoveryViewTest.kt b/app/src/test/java/com/droiddeck/launcher/ui/TrackingRecoveryViewTest.kt new file mode 100644 index 0000000000..3275e622f2 --- /dev/null +++ b/app/src/test/java/com/droiddeck/launcher/ui/TrackingRecoveryViewTest.kt @@ -0,0 +1,118 @@ +package com.droiddeck.launcher.ui + +import android.graphics.Bitmap +import android.graphics.Canvas +import android.view.View +import androidx.compose.ui.graphics.toArgb +import com.droiddeck.launcher.glasses.TrackingRecovery +import org.junit.Assert.* +import org.junit.Test +import org.junit.runner.RunWith +import org.robolectric.RobolectricTestRunner +import org.robolectric.RuntimeEnvironment +import org.robolectric.annotation.Config +import org.robolectric.annotation.GraphicsMode +import java.io.File +import kotlin.math.abs + +@RunWith(RobolectricTestRunner::class) +@Config(sdk=[34]) +@GraphicsMode(GraphicsMode.Mode.NATIVE) +class TrackingRecoveryViewTest { + private fun view()=TrackingRecoveryView(RuntimeEnvironment.getApplication()) + private fun render(view: View, width: Int=1920, height: Int=1200): Bitmap { + view.measure(View.MeasureSpec.makeMeasureSpec(width,View.MeasureSpec.EXACTLY),View.MeasureSpec.makeMeasureSpec(height,View.MeasureSpec.EXACTLY)) + view.layout(0,0,width,height) + return Bitmap.createBitmap(width,height,Bitmap.Config.ARGB_8888).also { view.draw(Canvas(it)) } + } + private fun save(bitmap: Bitmap, name: String) { + val file=File("build/reports/tracking-recovery/$name.png");file.parentFile!!.mkdirs() + file.outputStream().use { bitmap.compress(Bitmap.CompressFormat.PNG,100,it) } + } + + @Test fun recoveredTrackingRemovesTheScreenAndItsTouchTarget() { + val view=view() + assertEquals(View.GONE,view.visibility) + view.update(TrackingRecovery.LOST,false) + assertEquals(View.VISIBLE,view.visibility) + assertTrue(view.contentDescription.contains("Look around slowly")) + assertTrue(view.isClickable) + view.update(null,false) + assertEquals(View.GONE,view.visibility) + assertNull(view.contentDescription) + } + + @Test fun everyRecoveryStateHasItsOwnActionAndFitsThePhone() { + val view=view() + for((state,instruction) in listOf(TrackingRecovery.LOST to "Look around slowly",TrackingRecovery.RECENTER to "tap Recenter", + TrackingRecovery.STABILIZING to "Keep the glasses steady",TrackingRecovery.DISCONNECTED to "USB-access prompt")) { + view.update(state,false,Themes.byId(Themes.ELECTRIC)) + assertTrue(view.contentDescription.contains(instruction)) + render(view,1080,600).also { save(it,"phone-${state.name.lowercase()}");it.recycle() } + } + } + + @Test fun stereoDuplicatesTheWholeMessageForEachEyeAndMatchesMono() { + val view=view();view.update(TrackingRecovery.LOST,false) + val mono=render(view) + try { + view.update(TrackingRecovery.LOST,true) + val stereo=render(view,3840,1200) + try { + save(mono,"glasses-mono");save(stereo,"glasses-stereo") + val expected=IntArray(mono.width) + val eye=IntArray(mono.width) + val pixels=mono.width*mono.height + for(x in listOf(0,mono.width)) { + var changed=0 + var difference=0L + for(y in 0 until mono.height) { + mono.getPixels(expected,0,mono.width,0,y,mono.width,1) + stereo.getPixels(eye,0,mono.width,x,y,mono.width,1) + for(i in eye.indices) { + val actual=eye[i] + val reference=expected[i] + if(actual!=reference) changed++ + difference+=abs((actual and 255)-(reference and 255)) + difference+=abs(((actual ushr 8) and 255)-((reference ushr 8) and 255)) + difference+=abs(((actual ushr 16) and 255)-((reference ushr 16) and 255)) + } + } + // Native text rasterization can round a translated glyph edge differently. + assertTrue("Eye at x=$x changed $changed pixels",changed` captures the selected output. Inspect `GlassesMenu` log messages for capture or renderer failures. A display screenshot verifies image content; head movement and stereo comfort still require the physical glasses. diff --git a/docs/development/hand-hybrid-benchmark-2026-10-17.md b/docs/development/hand-hybrid-benchmark-2026-10-17.md new file mode 100644 index 0000000000..6b2594dd21 --- /dev/null +++ b/docs/development/hand-hybrid-benchmark-2026-10-17.md @@ -0,0 +1,110 @@ +# Hybrid hand inference benchmark + +Measured on the connected Samsung SM-F976U on 2026-10-17. This sparse-correspondence +prototype did not improve useful hand throughput. It was slower than scheduled stereo +on the central open-hand capture and accepted palms only on its dual-detector recovery +frames. The earlier estimated 20–60% throughput improvement is not supported by this test. + +Turning image lens correction off did not improve accepted-palm counts. The saved +calibration uses the **pinhole** distortion model, not OpenCV's fisheye model. The benchmark did not change its diagnostic build's live algorithm or input-rate policy, +and restored the prior settings after each sweep. That build ended with Lite selected. +The shipping baseline was subsequently set to Full with raw grayscale-to-RGB input. +The failed hybrid prototype and its runners have been removed; these results are historical. + +## Central open-hand result + +The table pools the initial and final central-scene runs in the lens on/off sweep. +Each stereo entry combines the baselines before and after the hybrids. Times include +per-frame image preparation, inference, matching when applicable, reconstruction, and +palm/gesture estimation. Acceptance means at least one geometrically accepted palm in +a repeated saved image, not live detection accuracy. This scene contains two open hands; +Full consistently recovered only one. + +| Full-model path | Image lens correction | Median / p95 processing | Frames with a palm | Sparse frames with a palm | +|---|---|---:|---:|---:| +| Scheduled stereo | On | 30.15 / 61.60 ms | 160 / 160 | — | +| Left-led hybrid | On | 62.59 / 84.06 ms | 48 / 80 | 0 / 32 | +| Right-led hybrid | On | 40.58 / 80.21 ms | 48 / 80 | 0 / 32 | +| Scheduled stereo | Off | 30.51 / 61.18 ms | 160 / 160 | — | +| Left-led hybrid | Off | 62.57 / 79.82 ms | 48 / 80 | 0 / 32 | +| Right-led hybrid | Off | 61.75 / 83.05 ms | 48 / 80 | 0 / 32 | + +All successful hybrid frames came from ordinary stereo inference. Correspondence failed +to reconstruct the five required palm anchors; the original palm gates were retained. +The first corrected-image trial measured about 19–21 ms for rectification and matching +alone. Repeated failures also prevented the hybrid from sustaining the cheaper one-hand +tracker schedule. The live input limit should not be raised on the strength of this candidate. + +Lite accepted no palms with either lens setting or either architecture on the lens-sweep +captures. The peripheral open hand and representative controller grip also yielded no +accepted palms. The no-hand control remained negative. The earlier corrected-image sweep +covered all nine saved pairs, including six controller grips, with no extra palms recovered +by the hybrid. These are a small set of static scenes, not independent accuracy trials. + +## What was measured + +`HybridHandBenchmark` was reachable only through the saved-capture diagnostic. Both models +use CPU VIDEO inference, the existing 0.6 thresholds, and the existing one-/two-hand +schedule. Stereo uses concurrent camera inference. The hybrid runs one detector, rectifies +both images, and searches for each landmark along its epipolar line using 11 × 11 normalized +correlation patches. It requires correlation at least 0.80, a 0.04 uniqueness margin outside +three pixels, patch standard deviation at least four, and forward/backward agreement within +1.5 pixels. Search depth spans 0.15–1.5 m. Existing triangulation and palm/gesture checks +remain in force. This is one concrete hybrid candidate, not a test of every stereo matcher. + +Both detectors run every fifth frame and on the frame after failed sparse palm estimation. +The hybrid's recovery costs and failures are included in the results. Each configuration +has a separate cold frame, five warmups, and forty measured frames. Synthetic VIDEO +timestamps advance by 50 ms, but processing runs unpaced; the experiment did not measure +a live 20 Hz stream. Initialization, file decoding, camera transfer, head synchronization, +pose publication, and rendering are excluded. Replayed poses are never published. + +Contrast normalization and grayscale-to-RGB conversion stay enabled in both lens cases. +With input lens correction off, detection runs on raw images; landmarks are still corrected +using calibration for triangulation. The hybrid always uses corrected, rectified images +for correspondence and transforms matched points back to the detector's image coordinates. +This comparison does not disable the geometric calibration required for metric depth. + +The lens sweep tested the central scene, peripheral scene, no-hand control, one grip scene, +and then the central scene again. Full and Lite each ran stereo-before, left-led hybrid, +right-led hybrid, and stereo-after for both lens settings: 3,200 measured replays. The +separate initial corrected-image corpus sweep also recorded 3,200 replays across nine +unique pairs, repeating the central scene last. Repetition is for timing, not extra accuracy +samples. SteamVR was idle and live tracking was temporarily disabled during these runs. + +## Validation and limits + +The Android build and 33 focused JVM tests passed. On the phone, the matcher passed fifty +synthetic correspondences in both directions and rejected textureless synthetic images +before each capture benchmark. These checks establish basic coordinate/search behavior; +they do not establish matching accuracy on real hands. + +Android thermal status was 0–1 during the corrected-image sweep and 1 during the lens +sweep. Timings varied substantially within the fixed configuration order, so the on/off +timing difference cannot be attributed solely to lens correction. Full stereo medians in +the first lens-sweep central trial ranged from 16.7 to 30.8 ms; the final trial was slower +with correction enabled. Baselines bracket the hybrid cases, but the run is not randomized +or temperature-controlled. + +The initial corpus's final Full/stereo-before trial included a 2,611.74 ms inference stall. +It remains in the raw samples and means; p95 alone hides that isolated stall. Geometric +acceptance does not apply live capture-age gates, so that observation would be stale in +live tracking. The later central lens-sweep samples had no processing times above 200 ms. +No moving-hand, pinch/release, sustained SteamVR throughput, external latency, or independent +position-accuracy pass is claimed. The present matcher needs better correspondence and +lower cost before a live increased-input-rate trial is justified. + +## Reproduction and evidence + +The temporary runner and matcher are no longer shipped. Local evidence from those runs: + +- Final lens comparison and raw samples: `build/hand-hybrid/lens/` and its `summary.json`. +- Initial full corpus: `build/hand-hybrid/corpus/` and its `summary.json`. +- First prototype trial: `build/hand-hybrid/first/`. +- Build and focused tests: `build/hand-hybrid-validation.log`. +- Lens comparison build: `build/hand-hybrid-lens-build.log`. +- Installed lens-benchmark APK SHA-256: `d976329b96e6aaceec62ef38085e203942cf763c51102adfeb50c4e5614891f1`. +- Calibration SHA-256: `3983438843877a321d3098f73496dfd9256f0088f095aa8d591602cf0b2cb213`. + +Each result also includes both capture-image hashes and the model hashes. Build-directory +evidence is local and may not be present in a fresh checkout. diff --git a/docs/development/hand-model-comparison-2026-10-16.md b/docs/development/hand-model-comparison-2026-10-16.md new file mode 100644 index 0000000000..c4d60311e2 --- /dev/null +++ b/docs/development/hand-model-comparison-2026-10-16.md @@ -0,0 +1,113 @@ +# Full versus Lite hand models and image preprocessing + +The saved-image comparison favors the Full palm detector and Full landmark model. +Neither contrast normalization nor lens correction improved usable bare-hand detections +on the two available bare-hand scenes. This is a small static corpus, not a live tracking pass. + +## Method + +The same saved 640 × 480 grayscale stereo pairs were evaluated with eight configurations: +Full or Lite palm/landmark bundles, each with raw input, calibrated lens correction, +1st/99th-percentile contrast normalization, or both corrections. Grayscale-to-RGB replication +and MediaPipe's model-required tensor scaling were enabled in every configuration. + +The main comparison ran on the Samsung SM-F976U using the app's Android MediaPipe Tasks +1.0.0 and OpenCV 4.13.0. Each configuration created fresh CPU VIDEO detectors, with two +hands per camera, parallel camera inference, and all detection/presence/tracking thresholds +at 0.6. Adaptive input and scheduled one-hand inference were excluded. Each pair received +one cold inference, four warmups, and twelve measured repetitions at synthetic 80 ms +timestamp intervals. Bare-hand mode was verified; wrist-only mode was false. + +This was an offline replay with the game idle and tracking cameras disconnected. It loaded +the phone's saved verified calibration and never initialized cameras or published replay +poses. Raw-image landmarks were undistorted during triangulation; corrected-image landmarks +were triangulated without applying distortion correction again. Both paths retained the +existing handedness, depth, reprojection, palm geometry, and motion checks. + +The corpus contains two bare-hand scenes, one no-hand control, and six controller-grip +scenes. The central bare-hand scene was also repeated at the end of the phone run. Replaying +one pair twelve times does not create twelve independent accuracy samples. Desktop IMAGE +and VIDEO tests using MediaPipe 0.10.21/OpenCV 4.11.0 provide a separate cross-check. + +## Bare-hand result + +For capture `64390821246320`, two open hands are visible in both cameras: + +| Image preprocessing | Full: usable stereo palms per replay | Lite: usable stereo palms per replay | +|---|---:|---:| +| Raw | 1 of 2 | 0 of 2 | +| Lens correction only | 1 of 2 | 0 of 2 | +| Contrast normalization only | 1 of 2 | 0 of 2 | +| Lens correction + contrast normalization | 1 of 2 | 0 of 2 | + +The cold frame and all twelve measured frames agreed. Full found one hand in each eye; +Lite found no hands with raw, lens-only, or contrast-only input. With both corrections, +Lite found one hand in the left camera and none in the right, so it could not reconstruct +a stereo position. + +Capture `72745789186883` contains one open hand, peripheral in the left image. Every +configuration missed it in both cameras throughout cold and measured replay. The desktop +IMAGE and VIDEO tests agreed with these bare-hand outcomes. The no-hand control +`59405518228482` returned zero hands across all configurations. + +The final repeat of the central scene reproduced the same cold and measured counts in +every configuration. All six controller-grip pairs (`110854218431877`, `110858058677761`, +`110862058272915`, `110935538464606`, `110939418512521`, `110943418461791`) produced +zero accepted stereo palms and zero accepted wrists in all measured phone replays. Some +Full configurations produced individual camera detections, but these did not become valid +stereo positions. Grip scenes are reported separately from the bare-hand comparison. + +## Phone timing + +These are median milliseconds for a parallel stereo pair on the central scene. They include +RGB preparation, inference, and result extraction, but exclude decoding, precomputed lens +correction, model initialization, and stereo reconstruction. They are not end-to-end latency. + +| Model | Preprocessing | First run | Final repeat | +|---|---|---:|---:| +| Full | Raw | 46.10 | 82.98 | +| Full | Lens only | 75.17 | 84.46 | +| Full | Contrast only | 85.64 | 82.99 | +| Full | Lens + contrast | 84.10 | 80.49 | +| Lite | Raw | 43.07 | 40.06 | +| Lite | Lens only | 37.29 | 39.70 | +| Lite | Contrast only | 38.73 | 42.54 | +| Lite | Lens + contrast | 78.78 | 75.34 | + +Android reported thermal status 2 throughout the saved-pair runs. Configuration order was +fixed, and inference work differs when a hand is found. Full/raw's first-versus-last variation +also prevents attributing the timing differences to preprocessing alone. Lite's lower timings +mostly accompany zero returned hands; its two-camera usable-hand result remains zero. + +## What normalization changes + +The saved calibration uses pinhole radial distortion coefficients (`fisheye: false`). The +comparison tests that calibrated lens correction, rather than forcing a fisheye model onto +the coefficients. Keeping the original camera matrix and output dimensions narrows the +field of view: the left output samples approximately raw x=96–544 and y=56–437, and the +right approximately x=93–547 and y=57–440. Some peripheral fingers near raw x=600 disappear +from the corrected left image. This is a concrete limitation of the current mapping, although +the raw version also failed to detect that hand; the crop alone does not explain all failures. + +Model tensor normalization was already provided by MediaPipe. The additional normalization +tested here changes image contrast. Replicating grayscale into RGB satisfies the input channel +contract but cannot recover missing color information. + +## Recommendation and limits + +Use Full with raw grayscale replicated into RGB as the next live baseline, retaining MediaPipe's +tensor scaling and calibrated point correction for stereo geometry. Full has the stronger +detection result here; extra contrast/lens preprocessing has no demonstrated acceptance gain +on these scenes. Broader motion testing is still needed before calling any configuration best +overall. Full itself still misses one of two central hands and the peripheral hand. + +The comparison used a temporary diagnostic build with opt-in preprocessing and offline replay. +That comparison code has been removed after selecting the Full/raw baseline; the live path +keeps grayscale-to-RGB conversion and calibrated point correction. Build, twenty focused JVM +tests, packaged runtime verification, and the installed Android replay were checked for the experiment. + +Local evidence is under `build/hand-comparison/`: `phone/` contains full per-frame results, +thermal snapshots and before/after status; `phone-summary.json` contains compact counts; +`desktop/` and `desktop-video/` contain the independent comparisons. The scripts are +`compare.py`, `compare_video.py`, `run_phone.py`, and `report_phone.py` in that directory. +`input-manifest.json` records all capture, calibration, and model hashes plus runtime versions. diff --git a/docs/development/luma-hand-tracking-investigation.md b/docs/development/luma-hand-tracking-investigation.md new file mode 100644 index 0000000000..6fa8b32ae8 --- /dev/null +++ b/docs/development/luma-hand-tracking-investigation.md @@ -0,0 +1,466 @@ +# Luma Ultra hand tracking investigation + +Date: 2026-10-17. Status: **experimental; gameplay usability has not passed**. + +## Current Full/raw baseline and hand rendering + +The stereo pipeline defaults to Full palm detection plus Full hand landmarks following the +[saved-image comparison](hand-model-comparison-2026-10-16.md). The optional Lite bundle contains +Lite palm and Lite landmarks; earlier historical timings describe a different Full-palm/Lite-landmark +bundle. `tools/build_hand_lite.py` pins both official Lite source models, +checks their input/output tensor contracts, and copies Tasks metadata from the Full bundle. +Both the outer task ZIP and the embedded label ZIPs have deterministic timestamps. + +Live inference consumes original grayscale camera bytes, replicated into reusable RGB buffers. +It skips full-frame lens remapping, contrast normalization, and the grayscale-to-RGBA-to-Bitmap +round trip. Preview bitmaps are created only at preview cadence; grayscale Mats are populated +only for calibration, validation, explicit capture, preview, or Joy-Con optical flow. + +Detection, preview overlays, and Joy-Con flow share raw image coordinates. Calibration corrects +the sparse landmark coordinates once before triangulation. The saved `fisheye` flag selects +fisheye or pinhole correction; the bundled Luma profile uses pinhole coefficients. Calibration +fitting, validation, and diagnostic captures retain their original raw images. The unsuccessful hybrid matcher and preprocessing-comparison code were removed +after baseline selection. The existing saved-pair diagnostic uses the same raw RGB +preprocessing and point correction as live tracking. + +Each grayscale byte is copied into R, G, and B without changing exposure or image coordinates. +[MediaPipe Tasks](https://ai.google.dev/edge/mediapipe/solutions/vision/hand_landmarker/android) +then performs model-specific tensor normalization from metadata; the app does not divide these +image bytes by 255 a second time. + +Joy-Con mode retains only landmark 0 (the wrist), triangulates and follows that position, and +does not estimate palm orientation, pinch, or grip. Replay follows the selected controller mode. +The landmark network still predicts all 21 landmarks internally. Physical Joy-Con +buttons and IMU orientation remain the controller input sources. + +The user reported that the hand smoothing and dead zones made tracking feel worse. The +common bare-hand `OpticalPose` path therefore removes the 3 mm position and 1-degree rotation +anchors and restores the earlier fixed 15 ms rendering interpolation, replacing the added +adaptive smoothing. Small accepted movements can change the rendered pose immediately. +Position prediction still requires consecutive velocities to agree in direction, preventing +alternating measurement noise from being extrapolated. The normal mode keeps measured palm +orientation; only the opt-in steady-aim setting uses `ShoulderAim`. Joy-Con filtering, gesture +release, observation freshness, and calibration gates are unchanged. + +SteamVR startup defers Luma Ultra 6DoF until two seconds after the first confirmed RUNNING +status. The launch gate applies before SDK initialization, with display controls available +through a nonspatial connection during the wait. Repeated RUNNING polls do not extend the +deadline. Stop, failed launch, and session cleanup cancel the pending start; reopening always +uses the current device and saved tracking settings. This changes startup sequencing, not the +tracking preference or hand-model configuration. +Automatic restoration on the same device, including a cancelled launch or early stop, +requests the existing stable-pose recenter. Status polls from superseded requests or ended +sessions cannot restart the pending tracking transition. + +Bare-hand controller rendering holds the last accepted pose for up to 350 ms from its original +capture timestamp, extending the previous 200 ms visual limit. Missing, invalid, or stale +observations freeze the rendered pose and stop prediction; repeated packets cannot extend the +hold. New observations still require the existing 200 ms freshness check, and trigger/grip +release immediately when their observations become invalid or stale. Head loss, origin or +connection changes, and controller-mode changes clear the visual cache. This bridges short +hand-detection gaps without adding a delay to fresh frames; it does not improve detection or +preserve a gesture through tracking loss. Both Full and Lite predict the 21 landmarks used by +the grab estimator; wrist-only Joy-Con mode uses physical buttons instead. + +Before this rollback, synthetic 12.5 Hz alternating-noise replay reduced position RMS from 4.354 to 1.772 mm and +rotation RMS from 1.722° to 1.398°. At 25 Hz, the respective changes were 1.242 to 0.988 mm +and 1.058° to 0.800°. The tradeoff in the 12.5 Hz slow-motion case was slightly more lag: +maximum position error changed from 0.423 to 0.593 mm and angular error from 0.489° to +0.632°. These results describe the reverted adaptive filter, not the current behavior or +measured live tracking improvements; the user's subsequent experience favored removing it. +The 80 focused JVM tests and native spatial, controller, adaptive-filter, and Joy-Con tests +passed. Build and installation evidence is recorded under `build/hand-baseline/`. + +The visual-hold follow-up passed the full native suite, including capture-age boundaries, +frozen rendering, stale-packet rejection, immediate gesture release, fresh reacquisition, and +cache invalidation. Only the VR driver changed among the 150 staged runtime outputs. +Build and installation evidence is recorded under `build/hand-visibility/`. + +The subsequent dead-zone/adaptive-filter rollback passed the full native suite. Regression +tests exercise 0.2 mm translation and 0.05-degree rotation immediately after settling, sustained +small motion, reversal, and the retained visibility/input protections. Synthetic 95% step +response was 44 ms after receipt at both 12.5 and 25 Hz observation rates. This measures the +render filter, not end-to-end camera latency. Only the VR driver changed among the 150 runtime +outputs; rollback evidence is recorded under `build/hand-filter-revert/`. + +The reviewed startup-delay follow-up passed 129 focused JVM tests, and an isolated snapshot +containing only the startup changes passed its 128 focused tests. Earlier phone logs recorded the spatial SDK +open attempt 3.348 seconds after confirmed SteamVR RUNNING: the two-second delay plus SDK +connection teardown. The resumed session reported valid 6DoF with no pending or required +recenter. The native driver and hand configuration were unchanged. Evidence is recorded under +`build/luma-vr-start-delay/`. The review fixes were rebuilt and installed, but the phone +reported no glasses connected during the follow-up, so hardware cancellation recovery +was not rechecked. + +The installed APK SHA-256 is `fac0973a21e41db842d88617bb11f16672987bd0b955736ad510abceca46b00f`. +Earlier connected-phone diagnostics confirmed `FULL`, `raw-grayscale-rgb`, +`pinhole-points-only`, concurrent CPU inference, scheduled discovery, adaptive input, +and `steadyHandAim=false`. Camera/head processing was active with the verified device +calibration. The launch check reached READY and staged VR driver SHA-256 +`e79525c144e934761f08cdc1d3170d058df89bf55c8458ddc955b58c90c9b128`, matching the rebuilt +payload. This verifies deployment and live processing, not moving-hand accuracy or comfort. + +The optional Lite bundle can be rebuilt with `mediapipe==0.10.21` using: + +```sh +python tools/build_hand_lite.py --palm palm_detection_lite.tflite --lite hand_landmark_lite.tflite +``` + +Source URLs and hashes are in `app/src/main/assets/models/hand_landmarker_lite.provenance.json`. +These changes still need live moving-hand, closed-fist, gesture-continuity, and latency validation. +Earlier Lite/normalized-input validation passed 52 focused JVM tests, and bundle rebuild and label-archive reproducibility +checks passed. Desktop MediaPipe 0.10.21 inference succeeded on color hand fixtures. All six +saved left-camera grayscale grip images still returned zero detections after correction and +contrast normalization at the existing 0.6 confidence thresholds. This is not a tracking-accuracy +pass. Synthetic projection/undistortion/triangulation checks stayed below 0.12 mm reconstruction +error for the bundled pinhole profile and near numerical precision for a synthetic fisheye profile. +Local reports for that implementation check are in `build/hand-lite-models/`; Android hardware +inference was not run at that stage. + +The subsequent [Full/Lite preprocessing comparison](hand-model-comparison-2026-10-16.md) +ran all eight model/preprocessing combinations on the phone using nine saved stereo pairs. +Full recovered one of two central open hands; Lite recovered no usable stereo hand. Neither +model found the peripheral hand, and contrast/lens correction added no accepted bare hands. +Full with raw grayscale-to-RGB input and calibrated point correction is now the live baseline; +the earlier comparison diagnostic itself did not change the defaults. + +There is room to improve the current implementation, but the available evidence does not support calling another smoothing adjustment a gameplay fix. The strongest current blockers are rejected palm reconstruction, interrupted gesture continuity, and processing latency under SteamVR load. The next useful milestone is a repeatable open → pinch → release interaction with a stable aiming pose, followed by sustained in-game testing. + +## What the existing evidence establishes + +The latest recorded post-installation interaction is `build/spatial-live-hands-sticky-grab-updated.json`, summarized by `build/sticky-grab-updated.log`. It belongs to Android process 17867 and SteamVR session `2026-10-16-60-steam`, using the stability candidate before the fork migration. It is historical evidence, not a measurement of the changes made during this investigation. + +| Finding | Evidence | Interpretation and limits | +|---|---|---| +| Head tracking remained available while hands failed | All 2,823 coherent channel samples had fresh head tracking; right hand was fresh in 1,446 samples (51.2%) | The observed interruption is in the hand path. This is sampled channel availability, not accepted-camera-observation rate; the user's exact hand visibility was not recorded. | +| Palm acceptance is a major failure point | Five of eight status snapshots reported matched/reconstructed hands but zero accepted palms | Detection alone is insufficient. The old message grouped missing palm anchors, implausible width, degenerate orientation, and temporal outliers together. It does not identify which gate caused each rejection. | +| Gesture continuity can prevent clicks entirely | The right-hand trace contained valid open and pressed pinch values, separated by loss transitions | Requiring a fresh observed release after loss is correct, but unreliable tracking can prevent a usable press sequence. See the replay below. | +| Processing already consumes most of the latency target | Eight reported processing times ranged from 63.3 to 114.0 ms; observation ages from 63.6 to 155.7 ms | These are internal status samples, not physical-motion-to-display latency. Some exceed the complete external p95 target of 100 ms before rendering is counted. | +| The run was thermally constrained | Android thermal status was 4; HAL skin temperature increased from 53.9 to 54.9 °C | This run cannot establish cold performance or isolate thermal throttling from game workload. | +| Latest stability changes did not establish usable interaction | The user reported similar stationary jitter and inability to start a dashboard drag | The previous candidate's automated tests and successful installation did not establish a hardware interaction pass. | + +The trace used CPU, full model, concurrent stereo inference, automatic input rate, and scheduled tracking. All eight diagnostic snapshots selected the two-hand search bank and a 500-permille camera copy rate. Approximately 25 Hz camera delivery therefore supplied at most about 12.5 eligible stereo pairs per second before processing and rejection. The left-hand channel had only 14 fresh samples; this was not a controlled two-hand visibility test, so that number is not left-hand detection accuracy. + +### Why a detected pinch may produce no click + +The right-hand transition list spans 15.885 seconds and contains 142 rows. Applying the current trigger rules from `tools/vr/src/spatial_tracking.h` to those sampled rows gives: + +| Trace quantity | Count | +|---|---:| +| Fresh, valid new observations below the 0.25 release threshold | 31 | +| Fresh, valid new observations above the 0.65 press threshold | 12 | +| Changes in the right trigger's loss-counter byte | 16 | +| Valid-palm transition rows with invalid pinch geometry | 58 | +| Above-threshold observations while the replayed trigger remained armed | 0 | + +Replay starts disarmed because the first sampled hand is invalid. It compares the low byte of the right hand's `epochs`, releases on invalid/stale hand or pinch data, ignores duplicate observations for arming, checks the 200 ms gap against the previous accepted hand timestamp, and arms only on a fresh valid trigger value below 0.25. A valid palm with invalid pinch still advances the hand observation timestamp, as in the driver. + +This is an inference from a sampled shared-memory trace. Sampling may omit intermediate observations, and this replay does not record what SteamVR or its dashboard consumed. It nevertheless gives a concrete explanation consistent with the reported inability to start a drag: the recognizer produces high pinch values, but continuity is lost before those values can form an armed press. Removing the release requirement would reintroduce presses on reacquisition and would not repair the observation stream. + +## Prioritized work + +1. **Measure each rejection before changing acceptance.** Count processed observations, valid palm/gesture observations, and rejection reasons separately for each hand. Distinguish no matching pair, missing triangulated palm anchors, palm width, degenerate orientation, implausible motion, synchronization, and age. Keep cumulative counters separate from sparse UI snapshots. These counters need no camera image recording. A broad reduction in stereo-quality thresholds could trade disappearing hands for incorrect depth and jumps. + +2. **Establish one reliable interaction sequence.** With a single visible hand at 30, 50, then 80 cm, repeat open → pinch → hold → release while collecting the observation counters and existing driver input-transition logs. Repeat for the other hand, then with both visible. Record whether failure happens before palm acceptance, at pinch validation, at arming, at OpenVR publication, or inside the dashboard. The dashboard uses trigger for click/drag; the installed Vive binding maps grip to Back. Keep the other fingers open during the pinch test so the two actions remain distinguishable. + +3. **Reduce measured processing cost and discovery spikes.** Run temperature-matched comparisons of full/scheduled CPU, lite/scheduled CPU, and input-rate settings, retaining the same game scene and deliberate motions. Measure completed-observation rate and accepted-observation rate, not camera rate or repeated channel reads. Existing saved-open-palm benchmarks show potential: under SteamVR, scheduled full inference had median/p95 46.92/94.71 ms versus full-search 91.48/99.26 ms; scheduled lite gave 40.26/86.77 ms. Those static-image results cannot establish moving-hand, pinch, or crossed-hand accuracy. The full model should remain the baseline until those comparisons pass. GPU requires a separate stability check because earlier evidence records graphics recovery/device-loss concerns. + +4. **Tune pose and aiming with motion evidence.** Record stationary raw and rendered pose distributions and a repeatable slow aiming path. At the time of this trace, driver stabilization held position within 3 mm and orientation within 1 degree around a stationary anchor, applied a 15 ms rendering correction, and bounded prediction to 2 cm/80 ms. The anchors have since been removed at the user's request. Increasing smoothing without measuring raw noise and lag risks making aiming less responsive. Test motion-aware filtering or a more stable aim direction only against the same recorded motions and external latency measurement. Aiming direction and a game controller's grip pose may need separate treatment. + +5. **Validate game compatibility after continuity.** Optical controllers currently expose Vive-compatible trigger/grip/trackpad inputs, with gamepad sticks and buttons supplying locomotion and menus; there is no skeletal hand output. `CardboardController::UpdateOptical` initializes `DriverPose_t` to zero and populates position and rotation, leaving linear and angular velocity zero. This is a source-confirmed omission to investigate for throwing and other velocity-dependent games, not an established cause of the dashboard problem. A velocity implementation needs capture-time derivatives, outlier/loss resets, a defined pose timestamp, and a game-level test before enabling it. + +Startup should be measured separately from steady state. Earlier logs contained shader-pipeline creation well after the dashboard appeared, while both hand detectors were already initialized. Correlate observation latency and CPU/GPU workload through launch and the following two minutes; model warmup alone does not explain the reported minute-long startup delay. + +The exported calibration also helps explain why a 3 mm stationary hold may have little visible effect. Its focal lengths are approximately 226–241 pixels and its stereo baseline is approximately 14 cm. The ideal rectified-stereo approximation `depth change ≈ depth² / (focal length × baseline) × disparity change` gives roughly 8 mm per disparity pixel at 50 cm and 20 mm at 80 cm. These are sensitivity estimates, not measured hand errors; the actual cameras have lens distortion and relative rotation. Independent landmark jitter can therefore exceed the driver's hold radius. If the new counters confirm palm reconstruction dominates, a robust fit across the available palm landmarks and temporal stereo correspondence are stronger candidates than simply enlarging that hold radius. Such a fit still needs explicit outlier rejection, side identity, capture-time freshness, and measured motion/gesture tests. + +## Vendor runtime options + +The public [VITURE Glasses C SDK documentation](https://www.viture.com/developer/glasses-sdk/glasses) describes USB management, head tracking, display control, and camera streaming, including Android support. It does not document a phone hand-tracking runtime that can replace this application's MediaPipe reconstruction directly. That is a statement about the published API reviewed on this date, not proof that VITURE has no private or forthcoming implementation. + +The [VITURE Unity SDK documentation](https://www.viture.com/developer/unity-sdk/unity) does describe hand tracking, responsive/stable filter modes, and arm/wrist contributions to aiming. Its stated hardware requirement and deployment instructions target the Pro Neckband. Those controls provide useful design references, but the documentation does not establish that their runtime can be redistributed inside this phone app. Confirm phone runtime availability, platform support, and licensing with VITURE before planning that replacement. + +## Calibration and completion criteria + +The phone's current calibration can be shipped as the Luma Ultra starting profile. That reduces setup friction; it does not fix inference cost, hand occlusion, gesture continuity, or jitter by itself. Preserve each device's own calibration as the higher-priority choice, restrict the base profile to its matching model and camera geometry, and identify it as a shared starting calibration. A calibration validated on the source glasses has not been independently measured on every Luma Ultra unit. + +Retain the existing acceptance gates in `luma-spatial-tracking.md`: at least 95% accepted slow unobstructed hand observations at 30–80 cm, no more than 5 cm position error and 2 cm stationary jitter, external p95 latency below 100 ms, reliable release and reacquisition, and no more than 10% regression in p95 game frame time over a 20-minute run. Dashboard selection and Angry Birds VR aim/grip/pull/release still require deliberate physical validation. Keep the feature visibly experimental until these tests pass. + +Supporting records: `luma-spatial-evidence.md`, `build/spatial-live-hands-sticky-grab-updated.json`, `build/hand-reliability-benchmark-smoothness-steamvr.json`, and `build/hand-startup-review.json`. The build-directory records are local historical artifacts and may not accompany a fresh checkout. + +## Joy-Con grip and arm extension investigation (2026-10-16) + +The target is a closed fist holding a controller, with the wrist and forearm visible from the +wearer's viewpoint. Open-palm performance is not sufficient evidence for this use case. In a +requested 16-second extension exercise, 5 of 80 sampled left positions and 1 of 80 right positions +were valid while head tracking stayed valid. These are channel availability samples, not 80 +independent detector results. The earlier driver also restarted its transition to the arm model +on each invalid hand frame, preventing intermittent camera positions from converging. + +The initial grip estimator required the wrist, middle base knuckle, and one supporting base +knuckle, rather than all five palm landmarks and a hand-derived orientation. The later +wrist-only update below removes the remaining knuckle dependency. It never generates hand +gestures; Joy-Con IMU and buttons remain authoritative. Stereo optical flow can carry the +identified wrist through brief model misses, with forward/backward consistency, photometric, +stereo reprojection and motion checks. Tracks expire 750 ms after the last detector seed; frame +gaps over 200 ms discard them. The driver retains a camera observation only until 200 ms after +its original capture time. Neither mechanism turns stale coordinates into fresh measurements. + +### Model assessment + +- **MediaPipe Full (historical baseline):** an existing Android pipeline with separate palm + detection and landmark regression. Curling fingers does not intrinsically exclude a hand, + but occlusion and the egocentric view must be tested with actual grips. Its published + monocular world landmarks are not used as metric camera distance; calibrated stereo supplies + distance. [Official task documentation](https://developers.google.com/edge/mediapipe/solutions/vision/hand_landmarker). +- **Earlier bundled Lite:** that bundle changed the landmark regressor while retaining the Full + palm detector (see `tools/build_hand_lite.py`). It can reduce processing cost, but cannot be + assumed to fix the initial fist-detection problem. Earlier saved open-palm replay under + SteamVR measured scheduled Full median/p95 46.92/94.71 ms and Lite 40.26/86.77 ms. Those figures + do not establish closed-fist accuracy. +- **RTMDet-nano hand detector plus RTMPose-m Hand5:** a concrete alternative detector and + landmark pipeline worth evaluating against grip frames. The official demo uses separate + hand boxes and landmarks. It is not a replacement `.task` asset: Android inference, + preprocessing, handedness/identity association, and device timings need integration and + verification. No claim of superior Joy-Con performance is established yet. + [Official hand demo](https://github.com/open-mmlab/mmpose/blob/main/demo/docs/en/2d_hand_demo.md). +- **HaMeR:** useful as an offline reference for occluded and egocentric hands, with published + evaluation procedures. Its reference implementation uses PyTorch, ViTPose, and MANO assets; + it is not an established real-time Android replacement for this app. Do not substitute its + inferred mesh depth for measured stereo depth. + [Official implementation](https://github.com/geopavlakos/hamer). +- **Whole-body arm pose:** not the first candidate for cameras on the wearer's glasses, + where the wearer's shoulders and torso are commonly outside view. An egocentric fist/wrist + detector or forearm segmentation model is the more directly matched development target. + This is an engineering assessment, not a measured comparison of those models on this device. + +The third camera is a separately exposed UVC pass-through camera, not an unused member of the +stereo callback. It may provide better RGB recognition, but requires its own capture/decode and +camera-to-head calibration. It does not independently provide metric depth. The preferred use +would be recognition or association assistance while stereo supplies distance; size-based +monocular distance would need separate calibration and uncertainty handling. +[VITURE SDK camera support](https://www.viture.com/developer/glasses-sdk/glasses). + +Saved-grip replay reports `joyCons` acceptance separately from bare-hand `hands`, for both Full +and Lite. Repeating one image measures model/geometry behavior on that image, not motion +continuity. Live tests must still check reach response, left/right identity, reacquisition, +camera loss, and head motion before considering the experiment reliable. + +### Closed-fist model comparison + +Three requested grip pairs were saved locally as captures `110935538464606`, `110939418512521`, +and `110943418461791`. In on-phone saved-frame replay of the middle and last pair, Full detected +one hand in the left image and none in the right image in all 20 measured repetitions per +configuration; Lite detected none in either image. Neither produced a valid grip position. +On the middle pair, scheduled Full median/p95 was 56.05/62.96 ms and Lite 46.00/47.99 ms. On +the last pair, it was 21.17/23.33 ms and 18.08/20.06 ms respectively. Timing differences between +frames are not accuracy improvements. Repeated static frames are not independent observations. + +An isolated Windows evaluator tested the official RTMDet-nano hand / RTMPose-m Hand5 ONNX +exports using `rtmlib` 0.0.16 and ONNX Runtime 1.31.0. Across the six raw images, hand-box counts +were 0, 0, 1, 0, 2, 1. Lens-corrected images gave 0, 1, 1, 0, 2, 1. Neither variant found both +hands in both cameras for any pair. These are box counts, not validated stereo positions or +ground-truth accuracy. Desktop timings cannot predict Android cost. Model downloads and hashes +are in `build/joycon-alternative-models/provenance.json`; results and overlays are local. + +MediaPipe desktop preprocessing comparisons used the same Full model asset with Python Tasks +1.1.1, versus Android Tasks 1.0.0. Overlapping 400-pixel crops recovered some missing detections; +lens correction and lower thresholds also changed detections and sometimes handedness. Only +isolated stereo matches passed the existing geometry checks. This does not justify enabling +either preprocessing change in the live pipeline yet, or replacing Full with Lite/RTMPose. + +The post-install shared-memory sample arrays in `build/joycon-reach-after.json` and +`build/joycon-reach-grip.json` are not valid live-pose measurements: the SteamVR session had +not restarted, so its pose publisher was inactive. Their before/after provider diagnostics and +requested image captures remain useful. During the actual closed-fist interval, all 253 +processed pairs reported invalid head tracking, so no live reach claim can be made. The local +measurement script now requires a running session, valid head tracking, and advancing head +timestamps to reject this situation. The image comparisons above do not depend on a live head +pose. A new live test is still required after head tracking and the session recover. + +### Third-camera grip comparison + +The separately exposed RGB camera delivered 1920 by 1080 JPEGs after Android Camera and USB +permissions were granted. SDK 2.4.0 crashed in `xr_camera_provider_start` when reopening the +provider in the main app process. RGB diagnostics now run in a dedicated process that skips +normal app initialization. Four initial successful captures preserved the main app PID. +Subsequent one-shot attempts intermittently returned zero callbacks despite a successful SDK +start. Keeping a stream open between requests did not resolve this: four successive startup +attempts returned zero callbacks. USB reconnection and a separate attempt with positional +tracking temporarily disabled also returned no frames. The user's decision was to stop the RGB +route and compare the models on stereo. The persistent-stream and RGB/stereo calibration-buffer +prototypes were removed; the isolated one-shot command remains for manual diagnostics only. + +Three requested normal-grip RGB captures (`112581486574499`, `112588468819444`, and +`112595950634337`) were evaluated with the same local model assets and thresholds: + +| Pipeline, full image | First | Second | Third | +|---|---:|---:|---:| +| MediaPipe Full | 0 hands | 0 hands | 2 hands | +| MediaPipe Lite | 0 hands | 0 hands | 1 hand | +| RTMDet-nano + RTMPose-m Hand5 | 2 hands | 2 hands | 2 hands | + +Overlapping square crops recovered one grip in the first image with Full and Lite; neither +recovered a hand in the second. The no-hands control image produced zero detections for all +three pipelines. Visual inspection of the alternative model's overlays found plausible wrist +locations on these grips, including the closer, partly cropped second view. Three selected +images are not an accuracy dataset or evidence of continuous tracking, identity preservation, +or measured reach. RGB results and overlays are in `build/joycon-rgb-evaluation`. + +The unchanged official ONNX models were also replayed on the Fold7 using Android ONNX Runtime +1.31.0 and OpenCV 4.13.0 preprocessing. Four warm-ups and ten timed iterations per image gave +two-thread median times of 119.90, 119.88, and 129.24 ms; the largest sample was 151.04 ms. +Four threads gave medians of 120.45, 120.79, and 121.05 ms. Timings include preprocessing, +detection, and two hand landmark passes, but exclude JPEG decoding, camera acquisition, +stereo depth, head fusion, rendering, and concurrent SteamVR load. Thus they already exceed +the 100 ms end-to-end target. The app's OpenCV DNN importer alone rejected the detector's TopK +operator; these measurements used a separate native benchmark, not a new production model +dependency. [ONNX Runtime mobile support](https://onnxruntime.ai/docs/get-started/with-mobile.html). + +The RGB SDK timestamps were zero on this device. Diagnostics record host callback receipt +separately. A temporary prototype successfully collected one nearby stereo pair with surrounding +frames, but the subsequent board attempt received no RGB frame. No RGB calibration was fitted. +Existing stereo calibration does not supply RGB lens parameters or the RGB-to-stereo transform. +RGB has never been used to publish controller positions in this experiment. + +### Stereo-only follow-up and wrist landmark 0 + +The alternative RTMDet/RTMPose pipeline was replayed on the Fold7 against the same three raw +stereo grip pairs, without RGB. With live Joy-Con inference temporarily paused, counts were +0/0, 1/0, and 2/1 hands in the left/right images. Per-image medians were 45.63/45.42, +129.35/45.03, and 199.50/123.13 ms. These are sequential single-image benchmark measurements, +not concurrent stereo latency or end-to-end tracking. Both candidate pairings in the last +capture failed the current geometry gates. The plausible wrist pair projected with 4.17 px +and 3.27 px error, exceeding the 3 px limit; the other pairing reconstructed behind the camera. +Neither a valid grip nor a valid isolated wrist was established. The log and geometry report +are `build/joycon-stereo-phone-ort-controlled.log` and +`build/joycon-stereo-phone-ort-geometry.json`. + +“Full” in this project is the full MediaPipe Hands landmark model, not a full-body model. +At the time of the model comparison, the live Joy-Con estimator used the midpoint of wrist 0 +and middle-finger base 9, validated with an additional base knuckle. The saved-pair diagnostic +added `wrists`, testing landmark 0 without those palm anatomy requirements. This cannot +recover a wrist when the upstream hand detector misses the grip in either camera. + +The existing desktop Full outputs at the production 0.6 thresholds, using raw uncropped +images, gave confident left/right counts of 0/0, 1/0, and 0/0. Thus none offered a wrist +pair even before palm geometry checks. Desktop Tasks 1.1.1 static-image evaluation differs +from Android Tasks 1.0.0 VIDEO replay and must not be presented as an Android measurement. +The local report is `build/joycon-mediapipe-wrist-evaluation.json`. The updated Android +wrist-only diagnostic was built and installed, but its replay is pending the glasses USB +approval after installation. The last phone settings check showed positional tracking on, +Joy-Con tracking off, and hand controllers off; there was no active stereo engine. + +Keep MediaPipe Full as the live baseline. The alternative's better RGB detections did not +transfer to dependable stereo grip positions on these captures. No new physical arm-extension +validation has been completed. + +### Live wrist-only Joy-Con position + +Following the user's correction, Joy-Con mode triangulates only landmark 0 and publishes its +position transformed through the camera-to-head and captured head poses. Knuckle availability, +palm proportions, and the wrist/knuckle midpoint no longer affect Joy-Con acceptance or position. +The estimator is `JoyConWristPosition`, and diagnostics report `joycon-wrist` with wrist-specific +missing-landmark and motion outcomes. Bare-hand gesture tracking still uses its palm geometry. + +Optical flow now seeds only the wrist and accepts a single tracked point per camera; the +previous three-point minimum is removed. Forward/backward and photometric checks, stereo +depth and reprojection limits, motion rejection, head synchronization, freshness, and track +expiry remain in place. Controller rotation and buttons still come from the Joy-Con, and +the driver still falls back to the arm model when fresh camera positions are unavailable. +This removes the unnecessary knuckle dependency, but does not bypass MediaPipe's hand +detector or establish continuous wrist visibility in the saved grip images. + +### RGB transport retry: hidden USB submission failure + +After the wrist-only test did not meet the user's needs, the RGB investigation resumed. +Capture `116048611549114` added stderr collection with `LIBUSB_DEBUG=4`, separate from the +vendor log hook. The SDK returned start status 0 and streaming status 1, but libusb reported +`submit_iso_transfer: submiturb failed, errno=12` (`ENOMEM`) and subsequent isochronous packet +errors. No RGB callbacks arrived. GET_INTERFACE showed alternate setting 5; the negotiated +UVC payload was 2400 bytes per microframe. This establishes USB allocation/submission failure, +not its exact resource limit: Android denied reading the USB memory-limit sysfs attribute. + +Binary inspection also traced the earlier native crash to `libusb_cancel_transfer(NULL)` +while cleaning up a failed start. Reopening alone was therefore too specific an explanation. +The embedded SDK's roughly 100-transfer queue is a plausible source of pressure. Its public +API cannot change the queue or the fixed 1080p30 mode. + +An optional independent diagnostic transport now uses libusb 1.0.30 and libuvc 0.0.8 with eight +queued transfers. The pinned libuvc source was patched to preserve submission errors and safely +drain partial queues instead of reporting success. A hardware-free executable passed 60 starts +on the phone covering failure before any submission, failure after three submissions, and all +eight submitted. This validates failure cleanup, not camera capture. The reproducible recipe, +source hashes, and licenses are documented in `docs/third-party/uvc/README.md`. + +Raw USB descriptors advertise MJPEG 640×480, 1280×720, and 1920×1080 among other sizes, with +30/25/20/15/10/5 fps intervals. The direct path can compare these modes while head/stereo tracking +continues. It saves a local JPEG plus transfer diagnostics and stream statistics; it is not yet +connected to controller tracking. RGB lens/extrinsic calibration and measured reach remain +separate unfinished requirements. + +### Direct UVC follow-up after the firmware update + +The glasses now report firmware `12.0.02.002_20260901`, previously +`12.0.01.100_20260326`. Direct UVC acquired short bursts, but no sustained stream: +capture `140416689286120` delivered 22 callbacks over 708 ms, followed by 4.3 seconds +without another callback. The main app stayed alive. These are transport observations, +not arm-extension measurements. + +The rejection logs exposed a separate parsing bug: valid JPEG end markers were followed +by one to seven zero bytes, with buffers aligned to eight bytes. The diagnostic now trims +up to seven trailing zeros before checking the end marker and saves the trimmed payload. +A native test on the phone covers padding, truncation, garbage, null input, and size bounds. +This fixes rejection of padded frames; it cannot recover missing USB callbacks. JPEG +boundary validation also does not establish successful decoding. + +A 32-transfer queue with eight packets per transfer was compared with the original +eight transfers of 32 packets. Both fault-injection builds passed 60 simulated starts. +The smaller transfers started 1080p30 without the earlier submission error, but received +zero frames (`140593211685272`). At 640p the smaller transfers still stalled after seven +callbacks (`140493747047289`). Neither configuration established reliable acquisition. + +Explicit USB device resets returned success but produced no frames at 640×480/30 or +320×240/5. GET_INTERFACE retained the selected alternate setting. Android's external +camera provider reported zero devices. A physical reconnect with positional tracking +disabled before attachment also yielded zero callbacks (`141363168667894`): capture +waited five seconds for the first frame and never entered its requested ten-second +observation window. The original positional and Joy-Con settings were restored afterward; +bare-hand controllers remained off. This failure occurs without the stereo/VIO stream. + +Capture evidence is under `build/joycon-rgb-captures/`, including `usb.log`, +`frame.json`, descriptors, and per-worker `libuvc-logcat.txt`. Teardown cancellation +messages are not evidence that transfers were cancelled during acquisition. RGB remains +diagnostic-only, with no RGB depth calibration or controller-position publication. + +Detailed USB logging in capture `141627121555242` recorded 224 successful isochronous +transfer completions over approximately 223 ms, each totaling 96 bytes, followed by no +successful completions until capture teardown. These small transfers did not produce a +decoded image or frame callback. A follow-up (`141844371790836`) read the UVC streaming +error code before and after the stall: both returned code 0. Android denied reading the +USB power-management sysfs attributes, so autosuspend was not verified as a cause. + +The user confirmed a direct VITURE cable connection. With the same glasses and cable +connected to Windows, FFmpeg/DirectShow decoded 300 frames in each of three ten-second +runs: 640×480/30, 1920×1080/30, then 640×480/30 after reopening. Outputs used passthrough +frame timing and frame hashes, with no frame-rate duplication or saved video. All exited +successfully without timeout. Evidence is in `build/joycon-rgb-windows`, produced by +`build/test-luma-rgb-windows.py`, which selects only USB VID:PID `0c45:636b`. This supports +investigating the Android host/USB path further; it does not prove the camera will be +reliable on every host or establish the exact Android fault. + +A controlled APK replacement of only `libusb.so` with official libusb 1.0.27 also +returned zero callbacks (`142296418051861`). Its source archive SHA-256 is +`ffaa41d741a8a3bee244ac8e54a72ea05bf2879663c098c82fc5757853441575`; provenance and the +one-entry APK comparison are under `build/rgb-libusb-1.0.27`. The production dependency +pin remains 1.0.30. An isolated YUYV 320×240/5 diagnostic negotiated format 2 but likewise +received zero raw frame callbacks (`142407601079475`), so JPEG validation was not its +failure point. Neither comparison changed the production camera format. + +Finally, 64 queued transfers of 32 packets increased the high-speed queue coverage from +approximately 32 ms to 256 ms. Its fault-injection executable passed all 60 starts. +Capture `142557405834522` recovered 18 valid JPEGs over 577 ms, then stalled for the +remaining 9.42 seconds of its ten-second observation. All 18 passed the padding fix; +the saved final JPEG also decoded at 640×480 in OpenCV. This is not sustained tracking +and neither alternate queue was adopted. Temporary USB reset, queue configuration, and +verbose logging experiments were removed. The retained UVC recipe uses eight transfers +of at most 32 packets, and retains the JPEG-padding fix. diff --git a/docs/development/luma-spatial-evidence.md b/docs/development/luma-spatial-evidence.md new file mode 100644 index 0000000000..210b25e3d3 --- /dev/null +++ b/docs/development/luma-spatial-evidence.md @@ -0,0 +1,445 @@ +# Luma Ultra implementation evidence + +Date: 2026-10-15. Status: experimental prototype, combined release gate not passed. Native 6DoF and synchronized stereo camera delivery were observed on hardware. Camera calibration and optical-hand acceptance were deferred at the user's request. + +## Device and build + +| Item | Observed value | +|---|---| +| Android host | Samsung Galaxy Z Fold7, SM-F976U | +| Android version | 17 | +| Glasses | SDK-confirmed VITURE Luma Ultra / Carina | +| Glasses firmware | `12.0.01.100_20260326` | +| Vendor SDK | External Android C SDK 2.4.0 | +| Test application | `com.droiddeck.launcher.xr`, debug experimental build | +| Camera pair | Primary left0/right0, both 640 by 480 | +| Hand runtime | MediaPipe Tasks Vision 1.0.0; OpenCV 4.13.0; pinned model SHA-256 in the model provenance asset | +| CPU or GPU inference benchmark | Not run; no accepted calibration | + +Existing picture, refresh-rate, and graphics work was preserved. The test temporarily enabled positional tracking and in-memory camera diagnostics. Diagnostics were stopped and the positional preference restored to its previous off setting afterward. Hand controllers were never enabled. No camera image recordings were saved. Subsequent builds are local artifacts; the phone was left available for a separate active SteamVR test. + +## Hardware observations + +Initial VIO output was unstable. After the user wore/moved the glasses and the software origin was recentered, valid 6DoF output was observed. Changing position values confirms positional data is available, but does not establish correct physical axes or 1:1 scale without a measured reference. + +Camera frames initially arrived before their matching VIO callback. A bounded wait of up to 35 ms in the latest-frame reader allowed matching timestamps without building a queue. The public callback's undocumented pose basis is not used; capture transforms come from canonical OpenGL pose history. + +A subsequent diagnostic interval produced these results: + +| Measurement | Result and scope | +|---|---| +| Sampled head validity | 30 of 30 status snapshots valid | +| Sampled camera/head synchronization | 30 of 30 status snapshots synchronized | +| Processed stereo pairs | Counter increased by 1,048 | +| Dropped stereo pairs | Counter increased by 9 | +| Median reported camera rate | 24.998 Hz | +| Median estimated frame age | 24.73 ms | +| Observed estimated frame-age range | 21.44–45.96 ms across the 30 snapshots | +| Median diagnostic processing time | 1.62 ms; no hand inference or calibrated undistortion | +| Host receipt age of latest head poll | 0.09–4.40 ms across sampled snapshots; not sensor latency | + +These are sparse status samples in an uncontrolled workload, not a frame-by-frame latency benchmark. Receipt-based source-clock mapping does not measure absolute camera exposure delay. None of these values establishes physical-motion-to-visible-controller latency, hand availability, or game-frame-time performance. + +Local raw metadata is in `build/spatial-hardware-observations.json`. The earlier startup/recenter observations are in `build/spatial-after-movement.json`, `build/spatial-recenter-state.json`, and `build/spatial-sync-state.json`. Those files contain pose/status metadata, not images. + +## Automated and build validation + +- SDK-enabled and explicitly SDK-free debug APK builds pass with runtime freshness checks enabled. +- All 305 affected Kotlin glasses, head-pose, Cardboard, and glasses UI tests pass with zero failures or skips. New cases exercise canonical coordinates, normalization, floor anchoring, crouched recenter, independent origins, stale/discontinuous samples, generation rejection, pose history, camera-clock warmup/reset, gesture geometry, and inference-buffer ownership. +- ARM64 VR driver and presentation-layer builds pass. Native tests cover ABI offsets and size, empty/truncated/version-mismatched or incoherent reads, independent hand timestamps, finite poses, stale tracking, trigger hysteresis, lost-input release and released-gesture rearming. Existing fence, timeline, and render-target tests also pass. +- Native Cardboard parameter tests cover all three translation values, zero-translation equivalence, and unchanged SBS/flat parameters. The GLSL compiles; the committed SPIR-V matches regenerated glslang output, and push constants remain within the guaranteed range. +- VR build manifests include the new shared header. Packaged runtime and APK payload checks reject mismatched source/output checksums. Both external vendor files and transient dependency-inspection files remain outside tracked source. +- Packaging regressions pass: 8 Windows VR build tests, 13 Windows preparation tests, and 11 runtime-input tests. Runtime-input tests ran in the Linux container because the Windows host has no standalone zstd executable. + +Build logs are `build/spatial-sdkfree.log`, `build/spatial-final-build.log`, `build/spatial-vr-build.log`, `build/spatial-shader.log`, and `build/spatial-runtime-evidence.json`. Test reports are under `app/build/reports/tests/testDebugUnitTest`. + +The preserved SDK-enabled snapshot is `build/DroidDeck-luma-spatial-experimental.apk`; the SDK-free counterpart is `build/DroidDeck-spatial-sdkfree.apk`. SHA-256 hashes and final payload checks are recorded in `build/spatial-final-validation.json`. The final local snapshot includes additional buffer-ownership and conservative tracking-loss fixes after the hardware smoke test. It was not installed over the phone being used for the separate SteamVR tests. Integrate these sources into that chat's next build before later calibration; do not replace its newer runtime-storage fixes with this older snapshot. + +A subsequent report from the parallel SteamVR test identified Android eviction of the live `cache/viture` directory. The SDK working-directory source was changed to `noBackupFilesDir/viture` afterward. The preserved APK snapshot and the hardware observations above predate this storage change. No additional phone restart or installation was performed here; the next shared-workspace build should include it. + +## Calibration usability follow-up (2026-10-15) + +The calibration screen now uses DroidDeck's saved palette, app scale, settings groups, and buttons, with separate tracking, capture, validation, and diagnostic sections. Eye height, virtual-screen dimensions, board instructions, and validation messages include imperial measurements. The distance check accepts either 20 inches (0.508 m) or 50 cm (0.5 m), using the selected value in reconstruction validation. + +Recenter requests made while the newest pose is stale or invalid were previously ignored. Requests now remain pending and are acknowledged immediately in the UI; recovery waits for 250 ms of fresh, steady tracking. Normal recentering preserves floor height, new connections cancel old requests, and captures cannot mix different VIO coordinate frames. Looking straight upward also retains a stable heading instead of deriving yaw from an almost-zero forward projection. Camera diagnostics resume when the provider restarts while setup remains open. + +Validation: 247 glasses and calibration/settings UI tests pass with zero failures or skips. The SDK-enabled debug APK builds, runtime input verification passes, and native Robolectric renders of the recovery and distance screens were visually checked. The APK's DEX files were checked for the new measurement controls. Logs are in `build/spatial-setup-build.log`; previews are in `app/build/reports/spatial-setup/`. The phone was not reinstalled or reconfigured during the other chat's SteamVR stability run. The user's reported repeated-recenter behavior still needs confirmation on the glasses after installing this build. + +After those stability tests finished, the combined calibration/recenter APK was installed at 17:09 MDT on October 15. Its SHA-256 is `80bf99374a31676b675856c782298aecc1e1c649ad2fc5c1ce3b18b981979e3e`; hashing the installed `base.apk` confirmed an exact match. The app cold launch and agent status checks passed. The helper, VR driver, and scheduling preload match the preceding freeze-tested build. This install confirms delivery of the latest calibration changes, not hardware acceptance of recentering or calibrated hands. + +## Capture counter fix (2026-10-15) + +Board detection checked head freshness against the worker's start time. A newer head poll arriving during detection made that timestamp precede the latest pose and rejected an otherwise valid capture. Completion now checks freshness under the session lock using the current monotonic time, while still rejecting stale poses, changed connections, changed tracking frames, and pending recentering. The same timing check was corrected around hand inference. Capture progress now exposes pending work and shows success or the rejection reason beside the counter, including the number of common board corners when detection fails. + +Validation: 24 targeted spatial and setup UI tests pass with no failures or skips, including the head-poll/detection timing regression and stale/disconnected-frame rejection. The SDK-enabled APK builds with runtime freshness verification. Build log: `build/spatial-capture-fix.log`. APK: `build/DroidDeck-spatial-capture-fix.apk`, SHA-256 `bf362bb606a3ec72665102b66e4a122c8fad9f5f7333f5a9a3ea3fef9a3bc9d5`. The installed Fold7 `base.apk` hash matches. + +With USB permission granted, valid native tracking, and synchronized stereo images at approximately 25 Hz, a live Capture board view action advanced the counter from 0 to 1 of 24 and reported success. The accepted view remains in the open calibration session. Status-only evidence is in `build/spatial-capture-fix-device.json`; no diagnostic camera recording was saved. This confirms capture acceptance and counter progression, not a completed calibration or optical-hand acceptance. + +## Calculation failure and compact setup follow-up (2026-10-15) + +The user reported calculation failure after at least 24 accepted captures; inspection found 35 observations still in memory. Logcat identified an OpenCV fisheye stereo fitting exception when successive views contained different corner counts (12–24 in this set). [OpenCV 4.13's implementation](https://github.com/opencv/opencv/blob/4.13.0/modules/calib3d/src/fisheye.cpp#L819) allocates its stereo residual blocks using the first view's count. The revised path fits fisheye intrinsics, undistorts every observed point, and fits stereo geometry with fixed intrinsics and zero residual distortion using the variable-count pinhole stereo solver. It retains every correspondence and still measures held-out error with the original lens model. Model failures are logged individually and the page shows the actionable reason instead of a generic failure. + +All 35 observations were exported from the debug app as board landmarks and head poses before installation, backed up in app-private storage, and restored on the same connected glasses. No diagnostic camera recording was taken. Accepted captures now save this metadata automatically; automatic recovery requires a matching serial and geometry, and recovered batches cannot accept new-frame observations. This device did not expose a serial, so recovery here was explicit through the debug interface. The session-labelled backup is not automatically trusted on later unidentified connections. + +The fixed fitter ran on the Fold7 with the restored set. Fisheye stereo fitting now completes, but both models fail stationary-board alignment: the best result varies by 25.5 cm (10.04 inches), above the unchanged 5 cm gate. The user confirmed the board was fixed. Offline replay showed a marked coordinate shift between the early and later observations; an exploratory fit of the first 13 observations agreed within 7.4 mm, while the full set did not. This suggests VIO frame motion/drift during collection; it does not establish its exact cause or validate a calibration from a selected subset. No profile was approved, and hand-controller acceptance remains blocked on a stable capture set plus measured-distance validation. + +The calibration page now has a single Back/title row and no fixed subtitle or eyebrow. A landscape regression check requires at least 75% of page height for scrolling, and both its rendered preview and the installed Fold7 layout were inspected. Guidance explicitly asks for gentle turns and tilts with a pause before each capture. The final SDK-enabled APK and 29 targeted tests pass, including saved-point parsing, stale-frame behavior, restored-batch UI, and landscape viewport coverage. Runtime freshness verification passes. Installed APK SHA-256: `1ca44c6b2b480b197ec0069db026b765d7927c30b7cea7b80cb67d50d626d38a` (verified against `base.apk`). Artifact: `build/DroidDeck-calibration-calculation-fix.apk`. Evidence: `build/spatial-calculation-fix.log`, `build/calibration-observations-backup.json`, `build/calibration-alignment.log`, `build/calibration-calculation-device.json`, and `build/calibration-layout-after.png`. + +## Distance-validation feedback follow-up (2026-10-15) + +A new 25-view capture set produced a fitted pinhole calibration with 1.12094 px held-out reprojection error and passed the existing alignment checks. The user then reported that Validate distance appeared to do nothing. Live status showed that it had run and failed, but the message was attached to Calculate camera alignment, above the visible distance controls. + +Validation now has independent pending/result state beside its own button. It reports partial-board corner counts, stereo-depth rejection, or measured versus selected distance in both units. It disables duplicate presses while pending and times out when no fresh camera image arrives. The complete-board requirement and 5 cm distance tolerance are unchanged. Processing errors are reported without stopping the camera worker. + +The 25 original observations and fitted geometry were backed up, then explicitly restored onto the same connected glasses after installation, retaining `verified=false`. The device still provides no serial; no cross-device or automatic unidentified-profile reuse was introduced. A live validation attempt on the updated app reported 3 of 24 common corners rather than silently failing. Physical-distance validation remains pending; the existing fit and captures remain available in the open setup session. + +Validation: 36 targeted tests pass, including visible validation feedback, pending-button state, complete-board/depth rejection, dual-unit output, camera-to-center distance, and unchanged tolerance. The SDK-enabled APK builds with runtime freshness verification. The result layout was rendered and visually inspected. APK: `build/DroidDeck-calibration-distance-fix.apk`; SHA-256 `1f0b288fdcb76231ecc9f5178f6621799b01f0eb83b574c79394fa1a04bb5f47`. Logs and metadata: `build/spatial-distance-fix.log`, `build/spatial-distance-apk.log`, `build/calibration-distance-fit.json`, `build/calibration-distance-captures.json`, and `build/calibration-distance-after.json`. + +## Near-distance detection fix (2026-10-15) + +The live stereo preview showed the complete printed board at the user's reported 20-inch position, but the pattern occupied only about 70 pixels across in the original 640 by 480 images. One explicitly requested diagnostic pair was saved. OpenCV 4.13 detected 16 left-camera checkerboard corners in the raw image and none after image undistortion; the right image detected 3 raw and 1 corrected. Neither version supplied a complete common board. This identified both limited marker resolution and additional loss from resampling, rather than paper edges being out of view. + +Distance validation now detects the original image pair and undistorts the detected coordinates before stereo reconstruction. Pinhole inversion uses an explicit convergence criterion. The UI defaults to 12 inches (0.3048 m), also offers 30 cm, and retains the 20-inch and 50-cm choices. Feedback distinguishes detected checkerboard corners from paper edges. The 24-common-corner, stereo reprojection/depth, and 5-cm physical-distance gates remain unchanged. + +Validation: all 36 targeted spatial/calibration/UI tests pass. Synthetic forward-projection and reconstruction checks exercise pinhole and fisheye point correction at 0.3048, 0.508, and 0.8 m; these verify geometry calculations, not hardware accuracy. The SDK-enabled build and runtime freshness checks pass, and the rendered result layout was inspected. APK: `build/DroidDeck-calibration-near-distance.apk`, SHA-256 `cd7e144e4fabb2e94872e4a762f1a641a61773902fa8fe40ec2c8c05d778f81d`; the installed Fold7 APK matches. Build log: `build/spatial-near-distance.log`. Synthetic results: `build/spatial-raw-landmark-geometry.json`. + +The same connected glasses' 25 accepted views and 1.12094-px fitted alignment were restored after installation without marking them verified. A subsequent user-triggered distance check reported **12.01 inches measured against 12.00 inches selected**, passing the unchanged validation gates and marking the calibration verified for this connection. Status evidence is in `build/calibration-near-distance-after.json`. Native head tracking and stereo synchronization remained valid at approximately 25 Hz. No optical hands were valid in that status sample; hand accuracy, externally measured latency, and game performance remain untested. Device identity is still unavailable, so automatic reuse across unidentified reconnects remains disabled. + +## Calibration persistence and hand-controller investigation (2026-10-15) + +After launching SteamVR, the app reported `calibrated=false`, zero restored views, and no optical observations despite valid native head tracking. Android USB did not expose a serial number, so the earlier calibration had stayed in memory. SDK 2.4.0's documented `xr_device_provider_get_sn_hash` returns a stable 32-byte board-serial digest. The adapter now reads it under the SDK ownership lock, rejects missing/zero digests, and uses it to key fitted profiles and captures. A nonblank Android USB serial remains a fallback. An unavailable identity still does not permit automatic cross-connection reuse. + +The existing 25 views and fitted geometry were explicitly imported onto the same physical glasses under the SDK identity with distance validation still required. The user repeated the check: **12.13 inches measured against 12.00 selected**. The app saved `verified=true`, and subsequent app installations/restarts automatically recovered the verified calibration and all 25 views without debugger restoration. This resolves the lost-calibration blocker; it does not establish reliable optical controllers. + +Hand diagnostics now distinguish missing calibration, synchronization/freshness failure, per-camera detections, ambiguous matching, rejected stereo geometry, and accepted hands. They retain the last completed result while inference runs, and expose preprocessing/inference timing. Observations over 100 ms old are cleared before publication; the driver and session freshness checks remain in place. CPU stereo inference runs concurrently with separate image buffers and waits for both tasks before frame reuse, including after one task fails. GPU inference remains on its owning thread. Calibrated undistortion maps are cached; comparisons against the original image-undistortion operations were pixel-identical for both cameras and both lens-model paths. + +SDK 2.4.0 documents the tracking cameras at 25 Hz and provides no stereo frame-rate setter. Faster application polling cannot raise that rate. The source-rate calculation now accounts for skipped frame sequence numbers; its earlier readout fell toward inference throughput when frames were dropped. + +Short live samples on the Fold7 do **not** pass the combined hand gate. In the final 12-sample CPU/SteamVR check, samples with detected hands took 87–137 ms to process, and no fresh hand was observed by the status reader. In the comparable GPU sample, hand-containing observations took 59–81 ms to process, with one accepted reconstruction but no fresh hand caught by the status reader. Earlier setup-only GPU samples did briefly report a fresh left hand. Stereo-depth rejection and observations exceeding 100 ms remain frequent. These are sparse internal timing samples with uncontrolled pose/thermal conditions, not externally measured latency, hand-validity percentages, or a controlled game-performance comparison. The user reported no visible controllers in SteamVR. An earlier 8-second guest-channel check found the 176-byte channel active with both feature flags set and all sampled heads fresh, but no fresh optical hands; both virtual controller devices were activated in the SteamVR log. + +One hand-landmark pair was inspected from the running reconstruction method without saving camera images. All 21 points triangulated within the broad depth range, but nine failed the unchanged 3-pixel reprojection gate. The wrist's error was 12.80 px; several fingers were approximately 3–4.3 px. Reconstructed palm width was 6.15 cm and depths were 28–41 cm. This is a correspondence/reconstruction failure, not a missing shared-memory channel. The single sample does not isolate calibration residuals from per-view landmark error, and no quality thresholds were relaxed. Data: `build/hand-stereo-point-diagnostics.json` and `build/hand-stereo-geometry-report.json`. Debugger pauses used for this inspection are excluded from performance evidence. The temporary GPU benchmark was ended with CPU mode restored; neither delegate has passed the combined gates. + +Validation: 51 targeted tests pass, including device-identity binding, concurrent stereo work, frame ownership after detector failure, calibration, gestures, and setup UI. SDK-enabled and SDK-free Android builds pass runtime freshness checks. Installed candidate: `build/DroidDeck-parallel-hands.apk`, SHA-256 `5e8ffa6a89a91e3b1b22fe289c126dca96a77dfb7645da551e8e97e13673c761`. Evidence: `build/spatial-parallel-hands.log`, `build/spatial-parallel-sdkfree.log`, `build/spatial-cached-undistortion.json`, `build/spatial-parallel-cpu-steamvr.json`, `build/spatial-cached-gpu-steamvr.json`, and `build/spatial-steamvr-hands-channel.json`. Calibration backup: `build/calibration-verified-profile.json` and `build/calibration-verified-captures.json`. The combined feature remains an experimental prototype. + +## Hand-mode color regression and CPU rollback (2026-10-15) + +The parallel CPU trial was removed after failing to improve live hand results. The serial worker retains cached lens maps, device-bound calibration persistence, and detailed rejection diagnostics. All 49 remaining targeted tests pass; the SDK-enabled APK builds with runtime freshness checks. Installed candidate: `build/DroidDeck-serial-hands.apk`, SHA-256 `bcefc87dabfde3d29f2018c2b39368d4e68cb015dd390385e3c80c74d86531c6`. Build log: `build/spatial-serial-rollback.log`. + +The user reported choppy head turns with hands and positional tracking disabled, then requested that this investigation be deferred because the phone was charging. A thermal snapshot reported status 4 and a skin sensor reading of 49.4 degrees C. The rendering log recorded approximately 55.5–60 fps at a selected 60 Hz. The retained 1.22-second prefix of a truncated head-channel diagnostic showed pose changes roughly every 3.2–6.6 ms, with no sampled gap above 7.5 ms. This small sample is not a controlled performance acceptance result. Evidence: `build/tracking-regression-sample.json`, `build/tracking-regression-analysis.json`, and `build/tracking-regression-wayland.log`. + +The HDR-like darkening is reproduced in screenshots of the glasses output, with brightness 6, Sunblock off, and valid head tracking unchanged. Camera inference enabled independently of optical-controller mode leaves normal colors. Enabling optical-controller mode with inference paused darkens midtones and shadows. A further test switching only `SpatialTracking.setHands`, bypassing the settings/menu/display-refresh path, also reproduces it. The temporary debugger overrides were removed after each comparison. This isolates the trigger to the SteamVR optical/untracked-controller path; it does not yet identify the faulty color-conversion operation. HDR output is disabled in the session. Evidence: `build/hand-color-comparison.json`, `build/hand-color-isolation.json`, `build/hand-color-mode-isolation.json`, and their `build/hand-color-*.png` screenshots. The calibration and 100-ms observation expiry remain unchanged. + +The serial candidate also passes the SDK-free build (`build/spatial-serial-sdkfree.log`). Temporary `TU_DEBUG=noubwc` did not remove the darkening, although the user changed display modes between that pair's screenshots. A subsequent `TU_DEBUG=gmem` comparison was interrupted by graphics recovery and is inconclusive. Neither diagnostic setting was retained: the following session's actual `vrserver` and `vrcompositor` environments both report an empty `TU_DEBUG`, and pending, active, and persistent agent overrides are empty (`build/hand-color-current-flags.json`). No gamma compensation or hand-validity workaround was added. + +The user's observation that SBS felt smoother coincided with 2D running at 60 Hz and SBS at 90 Hz. A later 120-Hz 2D request still reported a 60-Hz physical mode; its failure cause remains undetermined. The next 90-Hz 2D selection succeeded: Android reports 1920 by 1200 at 90 Hz, and the SDK reports mode `0x43`. The app therefore has no fixed 60-Hz limit for 2D. 2D and SBS retain separate refresh preferences; actual display mode must be checked independently of the requested value. Evidence: `build/hand-color-display-modes.txt` and `build/refresh-mode-final.json`. This confirms the active refresh mode, not sustained 90-fps game rendering or a thermal/performance acceptance result. + +## Color fix, original-image detection, and late synchronization (2026-10-16) + +The HDR-like color change is fixed and confirmed by the user in the glasses. `NewSharedVulkanImage` requested compute access for compositor eye textures even though DroidDeck only needs rendering and sampling. SteamVR replaced the requested `R8G8B8A8_SRGB` format (43) with `R8G8B8A8_UNORM` (37). The untracked-controller compositor path then produced dark linear midtones, while its multisampled controller path encoded colors differently. Removing compute access preserves format 43 in both paths. Temporary Vulkan tracing established the before/after formats and was removed from the delivered build; the presenter retains its existing byte-preserving UNORM import. No gamma compensation was introduced. Evidence: `build/color-format-fixed-trace.json`, `build/color-format-fixed-states.json`, and the corresponding on/off output images. The user reported that colors now stay the same when toggling Hand controllers. + +One explicitly authorized stereo image pair showed upright camera images and two visible open palms. Replaying it with the exact Android CPU detector found one left hand in each camera. All 21 landmarks passed the unchanged 3-pixel reprojection gate (maximum 2.227 px), with reconstructed palm width 7.31 cm and depth approximately 32–39 cm. The right hand was not detected consistently; lower confidence thresholds and exploratory crops did not establish an improvement and were not adopted. Hand detection now consumes the original grayscale images converted to RGBA and corrects landmark coordinates before triangulation, avoiding full-image resampling. This verifies one reconstructable sample, not sustained detection accuracy or two-hand operation. Evidence: `build/android-hand-pair-replay.json`, `build/android-hand-pair-geometry.json`, and `build/hand-pair-replay.json`. + +Previously, camera acquisition waited up to 35 ms for a matching VIO callback before starting hand inference. Inference now starts with the newest pair and checks the exact source timestamp again after detection, allowing VIO processing to overlap detection. Publication still requires a matching callback within 5 ms, a nearby canonical head-history sample, unchanged connection and tracking frame, healthy current head tracking, and an observation no more than 100 ms old. The callback's undocumented pose basis remains unused. Calibration and preview-only acquisition retain their bounded wait. Four additional regression tests cover late confirmation with the original capture pose, missing confirmation, expiry, tracking loss/discontinuity, reconnects, and unavailable history. + +Validation: 53 targeted Android tests pass with no failures or skips; SDK-enabled and SDK-free Android builds and runtime freshness checks pass. The ARM64 VR build passes its native layout, freshness, optical input recovery, render-target, synchronization, and scheduling checks. Temporary color tracing is absent from the final driver source and packaged runtime. Installed SDK-enabled artifact: `build/DroidDeck-spatial-color-sync.apk`, SHA-256 `885fb14b5a30ac65a255a6b0dd519d9f73b72489c08a8b74e1756673b86812ea`. Logs: `build/color-fix-final-native.log`, `build/color-fix-final-stage.log`, `build/spatial-late-sync-build.log`, `build/spatial-late-sync-sdkfree.log`, and `build/spatial-color-sync-install.json`. + +During the subsequent grey-screen report, the compositor continued presenting approximately 60 frames per second, but the SDK returned unstable head status 1 and the shared head pose was invalid. USB timeout messages also appeared; their causal relationship to tracking loss is not established. The clean app/provider restart preserved all 25 calibration views and the verified profile. After tracking recovery and software recentering, the user confirmed both “6DoF active” and the visible SteamVR dashboard. Positional tracking was briefly disabled for diagnosis and restored. No synthetic valid pose or silent fallback was added. Evidence: `build/grey-launch-guest.json`, `build/grey-launch-app.log`, and `build/spatial-color-sync-recovered.json`. + +The next 16-second left-palm test sampled the guest spatial channel 2,900 times: every head was fresh, but no optical controller pose was fresh. Six status samples showed one matched hand in both cameras and successful stereo reconstruction; inference took 139.7–174.3 ms and total processing 144.1–181.8 ms. Those observations correctly expired before publication. The other three status samples were waiting for synchronization. The app restarted between preparation of a temporary GPU benchmark and this measurement, so the active delegate was not verified in the new process and this is not a controlled GPU comparison. A later thermal snapshot reported status 4 and skin readings up to 51.0 degrees C; its contribution to the measured slowdown is unquantified. Evidence: `build/spatial-live-hands-left.json`, `build/spatial-live-hands-left.log`, and `build/spatial-hand-thermal.txt`. The glasses subsequently disconnected, preventing another live comparison. The next measurement needs a stable process/connection, explicit delegate verification, and controlled thermal conditions. Hand controls remain an experimental prototype and have not passed the combined release gate. + +## Tracking-loss recovery screen (2026-10-16) + +Active positional SteamVR and virtual-screen sessions now show a DroidDeck-themed recovery screen over the rendered output when head tracking becomes invalid. Separate states explain how to recover tracking, reconnect USB, recenter a changed origin, or hold still while recentering settles. The screen is rendered independently of the head pose, supports mono and SBS output, and closes automatically after valid tracking returns. The phone retains access to Recenter and glasses setup. No tracking validity, input-expiry, calibration, or driver behavior was relaxed. + +Validation: 65 targeted Android tests pass without failures or skips, including callback-free stale-pose detection, recovery states, presentation surface preservation, mono/SBS rendering, and theme colors. Robolectric native-rendered previews were visually inspected at 1080 by 600 and 3840 by 1200; this is automated rendering evidence, not a physical glasses acceptance check. SDK-enabled and SDK-free Android builds and packaged-runtime freshness checks pass. Logs and previews: `build/tracking-recovery-build.log`, `build/tracking-recovery-sdkfree.log`, and `app/build/reports/tracking-recovery/`. + +Installed SDK-enabled artifact: `build/DroidDeck-tracking-recovery.apk`, SHA-256 `2170c2e513d45af048b9aba01b76a694d333ba9848a91021a47d413fca3d282d`. Installation preserved app data and was performed with the session idle; SteamVR was not started. The installed APK hash matches the archived artifact (`build/tracking-recovery-install.json`). A live tracking-loss/recovery check through the glasses remains pending. + +## Cooled-phone retest and visible left controller (2026-10-16) + +The Fold7 initially reported thermal status 1, approximately 40.3 degrees C skin temperature, healthy USB access, and the saved 25-view calibration. Head tracking recovered to valid status 0. CPU inference was verified through the live setup control in process 17409, session 12. By the 16-second left-palm measurement, thermal status had returned to 4. All nine diagnostic samples detected and reconstructed a matching hand in both cameras, but inference took 124.4–173.3 ms. The guest channel had 3,038 fresh head reads and zero fresh hand reads. This does not establish an unthrottled CPU baseline. Evidence: `build/cooled-cpu-verified-ui.json`, `build/spatial-live-hands-cooled-cpu.json`. + +Enabling GPU inference while that SteamVR session was running initialized both GPU graphs, including OpenCL loading, at 01:10:24–01:10:27 device-local time. The compositor first reported `vkerror=-4` at 01:10:29.516; automatic graphics recovery then killed and restarted the app. Process 27927, session 13, was back on CPU. The subsequently captured file named `build/spatial-live-hands-cooled-gpu.json` therefore contains CPU observations after recovery and must not be counted as a GPU comparison. Process IDs, session IDs, the setup control returning to Off, and Android exit records establish that reset. The timing associates GPU initialization with the device-loss event but does not establish its underlying driver cause. Evidence: `build/cooled-before-restart-logcat.txt`, `build/cooled-session12-vrcompositor.txt`, `build/cooled-session12-events.jsonl`, `build/cooled-exit-info.txt`, `build/cooled-gpu-after-ui.json`. + +With SteamVR stopped, GPU inference was enabled and verified in process 27927. Twelve diagnostic samples then measured 10.3–14.1 ms inference and 12.0–19.7 ms total observation age, with healthy head tracking. These samples were not a prescribed palm-hold accuracy test; most saw a hand in only one camera and none produced accepted geometry. Evidence: `build/cooled-idle-gpu-verified-ui.json`, `build/cooled-idle-gpu-sample.json`. + +Launching SteamVR after GPU initialization preserved process 27927 for session 14. During a fresh 16-second left-palm hold, the guest channel received 67 distinct valid left-hand observations. The left hand was fresh in 315 of 2,864 coherent channel reads (11.0%); all heads were fresh. This percentage measures sampled channel availability, not the acceptance target's percentage of camera observations. The user confirmed a controller appeared or flickered. Eight diagnostic samples all reconstructed the left hand, but inference varied from 41.8–101.6 ms and observation age from 72.5–131.9 ms. Thermal status remained 4, with reported skin temperature increasing from 49.1 to 51.3 degrees C. The session also logged another Vulkan device-loss event, so initializing GPU inference before SteamVR did not resolve stability. Evidence: `build/spatial-live-hands-prewarmed-gpu.json`, `build/cooled-prewarmed-start.json`, `build/cooled-session14-events.jsonl`. + +This confirms a visible optical left-controller path, with no relaxed timestamp or geometry checks. Both-hand reliability, gesture operation, measured end-to-end latency, and sustained performance remain unvalidated. No camera images were saved during these tests, and calibration was not changed. The run was stopped after the repeated graphics fault. After confirming the session was idle and its artifacts complete, DroidDeck was closed to stop background inference and clear the temporary GPU benchmark; saved settings and calibration were retained. The next work must address GPU/SteamVR coexistence and inference latency under sustained thermal load; another calibration is not indicated by these successful left-hand reconstructions. + +## Requested 200 ms experimental hand cutoff (2026-10-16) + +The user requested accepting hand observations up to 200 ms old to reduce disappearing controllers while inference is slow. The cutoff now applies consistently to inference admission/completion, capture-pose lookup, Android publication, and SteamVR optical pose/input freshness. Observation timestamps are unchanged. Head freshness remains 100 ms, and detected loss, changed tracking frames, reconnects, and recentering still invalidate hands immediately. Missing observations can now retain trigger/grip until the 200 ms expiry; reacquisition still requires an observed release. This intentionally changes the earlier 100 ms hand-expiry requirement, without claiming lower processing latency or resolving the Vulkan faults. The diagnostics field `handMaxAgeMs` reports the active limit. + +Validation: 73 targeted Android tests pass, including a 150 ms inference result using its original capture pose, the inclusive 200 ms boundary, rejection immediately after that boundary, unchanged 100 ms head expiry, and independent hand timestamps. Native tests pass the same hand/head boundaries, pose validity, stale-input release, and reacquisition behavior. The ARM64 driver was rebuilt, staged, and verified against source/output checksums; SDK-enabled and SDK-free Android builds pass. Logs: `build/hand-200ms-native.log`, `build/hand-200ms-stage.log`, `build/hand-200ms-build.log`, `build/hand-200ms-sdkfree.log`. + +Installed SDK-enabled artifact: `build/DroidDeck-hand-200ms.apk`, SHA-256 `dac9296cbc964fca87b65b7e1e8b87276deaaeb5d90ca731d47eae673e22c64d`. Its packaged driver matches the rebuilt ARM64 binary, SHA-256 `bf24667f9f288cd07efe6e100c3b237b1e68b734100ae99cf93974538ce3bc6a`. The installed APK hash and live `handMaxAgeMs: 200` were verified. Calibration and saved settings were preserved. SteamVR was not launched, and the app was closed after verification to stop background inference (`build/hand-200ms-install.json`). Live controller availability, gesture delay, and release behavior with the new cutoff remain unmeasured. + +## GPU default requested by the user (2026-10-16) + +The user explicitly requested GPU inference as the default. Every new stereo hand engine now selects GPU, including after app restart, USB reconnect, and provider restart. The setup control is renamed **GPU hand inference** and explains that disabling it selects CPU until the next tracking restart. Diagnostics distinguish `handGpuEnabled` (selection) from `handInferenceBackend` (GPU/CPU only after both detectors initialize, otherwise `not initialized`). This replaces the earlier CPU-default policy; it does not resolve the measured Vulkan failures or constitute performance acceptance. The 200 ms hand cutoff and gesture mappings are unchanged. + +Validation: 73 targeted Android tests pass, including pinch/grip mapping, expiry, tracking recovery, and setup UI. SDK-enabled and SDK-free builds and runtime freshness checks pass. The packaged driver still matches the previously tested 200 ms ARM64 binary. The active SteamVR test was stopped cleanly before installation. GPU selection and the verified calibration were confirmed in two distinct app processes, 22127 and 23157, separated by a full app restart. Head tracking was valid, but hand diagnostics reported waiting for camera/head synchronization and the detectors reported `not initialized`; these checks verify default selection and profile persistence, not a new live GPU inference or gameplay result. SteamVR was not relaunched. + +Installed SDK-enabled artifact: `build/DroidDeck-hand-gpu-default.apk`, SHA-256 `a32feb647b0ca9fb6f62bd31158450b58e5671de7c1b0324f6b0b56bd4c92a47`. The installed APK hash matches. Evidence: `build/hand-gpu-default-build.log`, `build/hand-gpu-default-sdkfree.log`, `build/hand-gpu-default-install.json`. Click instructions are documented: present an open hand, aim the virtual controller, pinch thumb and index finger to press, and separate them to release. Curling the middle, ring, and little fingers supplies grip; tracking loss requires another observed open/released gesture before input can resume. + +## CPU default restored and model optimization investigated (2026-10-16) + +After further SteamVR restarts, the user requested reverting to CPU. New engines, the no-engine diagnostics fallback, and the setup UI now default to CPU again. The optional GPU toggle explains the observed restart risk and resets on tracking restart. Calibration, the color fix, and the requested 200 ms hand cutoff are retained. GPU device loss has not been fixed or ruled out under other configurations. + +Validation: 73 targeted Android tests pass with no failures, errors, or skips. SDK-enabled and SDK-free builds pass; the SDK-free APK excludes the optional VITURE bridge. The SDK-enabled APK's packaged ARM64 driver matches the previously tested 200 ms binary. CPU selection (`handGpuEnabled: false`) and the verified 25-view calibration were confirmed in two distinct processes, 3540 and 3717, across a full app restart. Head tracking was lost and hand detectors were `not initialized` during these checks, so this verifies the restored default and preserved calibration, not new live CPU performance or SteamVR stability. + +Installed artifact: `build/DroidDeck-hand-cpu-restore.apk`, SHA-256 `5ae8f702fdce16501a69731fd5b0e718198e267276e918322b15228ae3b95282`. The installed APK hash matches. Driver SHA-256 remains `bf24667f9f288cd07efe6e100c3b237b1e68b734100ae99cf93974538ce3bc6a`. Evidence: `build/hand-cpu-restore-build.log`, `build/hand-cpu-restore-sdkfree.log`, and `build/hand-cpu-restore-install.json`. SteamVR was not launched for this verification. + +The shipped bundle already uses float16 weights. This does not establish float16 CPU arithmetic or a speed advantage: Google's [float16 documentation](https://developers.google.com/edge/litert/conversion/tensorflow/quantization/post_training_float16_quant) describes CPU weight expansion to float32. [INT8 quantization](https://developers.google.com/edge/litert/quantization/model_optimization) is a possible separate experiment, subject to runtime/operator compatibility and stereo accuracy validation; no INT8 conversion or speed claim has been made. + +An offline feasibility experiment compared Google's [legacy lite palm and hand landmark models](https://github.com/google-ai-edge/mediapipe/blob/master/docs/solutions/models.md) against the installed full bundle using the previously authorized stereo image pair. No new images were captured. The lite models initially failed the Tasks loader because normalization metadata was absent. For this local experiment, input/output tensor names, shapes, and types were checked against the full models before copying their metadata and associated files. The 0–1 input normalization agrees with Google's [hand landmark graph](https://github.com/google-ai-edge/mediapipe/blob/master/mediapipe/modules/hand_landmark/hand_landmark_cpu.pbtxt) and [palm graph](https://github.com/google-ai-edge/mediapipe/blob/master/mediapipe/modules/palm_detection/palm_detection_cpu.pbtxt). Experimental bundles remain under `build/hand-lite-research/`; the app still ships the original checksum-pinned full bundle. + +Windows CPU replay used MediaPipe 0.10.21, two sequential VIDEO instances, two-hand capacity, unchanged 0.6 confidence thresholds, 10 warmup pairs and 30 timed repetitions of one static pair. Times cover stereo inference only, excluding camera acquisition, preprocessing, geometry, rendering, and Android/game contention. + +| Models | Median stereo inference | p95 stereo inference | Static-pair geometry | +|---|---:|---:|---| +| Full baseline, before alternatives | 84.54 ms | 97.28 ms | Left hand passes in 30/30 repetitions | +| Lite palm + full landmarks | 37.11 ms | 43.94 ms | No hands detected; unusable for this sample | +| Full palm + lite landmarks | 62.48 ms | 73.18 ms | Left hand passes in 30/30 repetitions | +| Both lite | 36.75 ms | 43.69 ms | No hands detected; unusable for this sample | +| Full baseline, after alternatives | 87.99 ms | 100.15 ms | Left hand passes in 30/30 repetitions | + +Full palm plus lite landmarks is approximately 26–29% faster by median in this limited desktop replay. Its first-frame maximum reprojection error is 1.83 px versus 2.23 px for full; this single-pose result is not an accuracy comparison across real interactions. Repeated images do not validate motion, tracking availability, both hands, reacquisition, or thermal performance. Android Tasks 1.0.0 compatibility and temperature-matched Fold7/SteamVR measurements are still required before adopting it. The apparent speed of the lite-palm variants is not useful evidence of faster working tracking because they performed no landmark inference on a detected hand. + +Research artifacts: `build/compare-hand-lite.py`, `build/hand-lite-research/results.json`, `build/hand-lite-research/without-metadata.json`, and `build/hand-lite-research-metadata.log`. Original downloaded SHA-256 values: palm lite `e9a4aaddf90dda56a87235303cf00e4c2d3fb28725f68fd88772997dac905c18`; landmarks lite `d7fde8ac11f8ce03f8663775bfc323f4fc9f2a38062b4f4efa142874ef5b2a48`. + +Another candidate is reducing repeated palm searches without losing second-hand acquisition. The [upstream HandLandmarker graph](https://github.com/google-ai-edge/mediapipe/blob/master/mediapipe/tasks/cc/vision/hand_landmarker/hand_landmarker_graph.cc) runs detection whenever tracked hands are fewer than the configured maximum, including one visible hand with a two-hand limit. This is a profiling lead, not a measured attribution in the packaged Android runtime. Simply setting the limit to one would remove the required two-hand behavior; implementing a controlled search cadence would require a different graph or pipeline. The existing bounded latest-frame queue and VIDEO tracking already avoid unbounded backlog and unconditional IMAGE-mode detection. + +## Brief visual hold and remaining detection gaps (2026-10-16) + +After the user reported recovery following cooling, a 16-second CPU sample kept the same Android process (10308) and SteamVR session (`2026-10-16-29-steam`). Head tracking was fresh in 2,851 of 2,857 channel samples (99.8%), but the left hand was fresh in only 22 samples (0.77%), representing six distinct poses. Those poses first reached the monitor 162.2–198.3 ms after observation. Right-hand output was absent during the requested left-hand-only test. Diagnostic snapshots alternated between camera/head synchronization waits and no detected hands; measured inference in the snapshots that ran detection ranged from 76.1 to 136.8 ms. This is not a controlled cool-device benchmark: at the end Android reported thermal status 4 and the current HAL SKIN sensor read 51.5 C. Evidence: `build/spatial-live-hands-cooled-flicker.json` and `build/cooled-flicker-measure.log`. + +The driver previously invalidated its rendered controller immediately whenever an inference result contained no hand, even if the previous observation was still younger than the requested 200 ms cutoff. It now caches only the most recent accepted optical transform for visual continuity through those short gaps. Expiry remains measured from the original camera observation; a missed result never extends it. Optical input processing remains separate and releases trigger/grip immediately on a miss. Reacquisition still requires a released gesture. Head loss, connection/origin changes, disconnect, and switching back to gamepad-positioned controllers clear the cache. Missing optical tracking no longer suppresses independently available gamepad menu and locomotion inputs. This is a partial flicker mitigation, not a remedy for the longer detection gaps or old poses measured above. + +Native regressions pass for immediate gesture release during a held visual pose, its unchanged timestamp and inclusive 200 ms boundary, rejection after expiry, rearming, head loss/recovery, origin/connection changes, disconnect, mode changes, malformed/future/out-of-order samples, and gamepad availability during optical loss. The other native rendering, fence, and scheduling regressions pass. SDK-enabled and SDK-free Android packaging and runtime source/output freshness checks pass. Android application source was unchanged in this step; the existing 73 passing Android test results were checked during installation rather than rerun. Evidence: `build/hand-visual-hold-native.log`, `build/hand-visual-hold-stage.log`, `build/hand-visual-hold-build.log`, and `build/hand-visual-hold-sdkfree.log`. + +Installed artifact: `build/DroidDeck-hand-visual-hold.apk`, SHA-256 `977b993433803f3d8abbd639ca636b874367467866b58f7af75a07a46b20daa2`. Its packaged ARM64 driver matches the tested build, SHA-256 `2d7ff8647f210248f6ea4b68e9b05e21ed7ebcc74da601da0f1d854067b7ab82`. Installation occurred with the session idle and preserved the calibration/profile files. CPU selection and the 200 ms setting were confirmed across two app processes. The glasses were disconnected during these checks, so calibration was not loaded and detectors were not initialized; this does not establish a live improvement. SteamVR was not relaunched. Evidence: `build/hand-visual-hold-install.json` and `build/hand-visual-hold-live.json`. + +The user explicitly authorized one new diagnostic stereo pair and separately authorized copying that pair and timing metadata to the local workspace. Both 640 by 480 images visibly contain the palm, near the outer edge of the left image. The saved pair was not synchronized to a head pose. Desktop MediaPipe 0.10.21 replay of the current full model failed to detect either hand at palm-detection thresholds 0.6, 0.5, 0.4, and 0.3, with landmark-presence confidence held at 0.6. Undistorting the images before detection did not recover this sample. Lowering both confidence thresholds to 0.3 also failed. A fixed right-side image tile detected a left hand in only one camera, insufficient for stereo reconstruction. The earlier authorized pair still detected the left hand in both cameras and passed the unchanged stereo geometry gate in the same replay. These static diagnostic experiments do not justify changing thresholds, shipping a fixed crop, or claiming general detection improvement. No inference model, thresholds, or stereo quality gates were changed. Local artifacts: `build/flicker-pair-replay.json`, `build/flicker-pair-scale.json`, and their scripts/logs. + +The earlier CPU crash investigation also observed Vulkan device loss with hand inference disabled. A temporary `TU_DEBUG=noubwc` session reproduced it and was stopped; the flag was not persisted and no production graphics change was made. Cooling may have contributed to the user's reported recovery, but neither overheating nor inference delegate choice is established as the sole crash cause. + +## Half-rate stereo input requested by the user (2026-10-16) + +The supplied SDK 2.4.0 Carina header documents 25 Hz camera/pose callbacks and exposes automatic/manual exposure controls, but no tracking-camera frame-rate setter. DroidDeck now selects every other callback for its own stereo pixel copies while hand controllers are enabled, yielding approximately 12.5 pairs per second with the observed 25 Hz input. The gate executes before native buffer resize/copy. Skipped pairs do not reach JNI transfer, grayscale/RGBA conversion, or hand inference. Vendor camera acquisition/VIO, pose callbacks, and the existing head polling interval are unchanged. This is software input decimation, not a firmware camera-rate change. + +Calibration collection, distance validation, explicit diagnostic capture, and preview-only use bypass the half-rate gate. The first frame after a gate-mode change or camera-source reset is accepted. The latest eligible pending pair still replaces older eligible pending work. Camera-source/receipt timestamps and the existing 200 ms hand expiry are unchanged. JNI metadata carries the incoming frame index associated with the copied pair and the cumulative intentional skip count, so diagnostics continue to report the true incoming camera rate. `cameraFrameDivisor: 2` identifies hand input at half rate, and `rateLimitedFrames` is separate from processing-related `dropped` frames. The setup UI explains both rates and counters. + +The native regression passed 250 source callbacks producing 125 copied pairs, full-rate setup, repeated configuration, source reset, invalid timestamps, and reconnect reset. All 75 targeted Android tests passed, including half-rate camera-clock mapping and UI separation of incoming rate versus intentionally skipped frames. All 13 runtime-preparation tests passed, including classifying the new native helper as locally compiled while rejecting unrelated donor-native reuse. SDK-enabled and SDK-free builds and runtime freshness checks passed. Tests: `tools/tests/test_stereo_frame_gate.cpp`; logs: `build/hand-half-rate-build.log`, `build/hand-half-rate-sdkfree.log`, `build/hand-half-rate-runtime-tests.log`. + +Installed SDK-enabled artifact: `build/DroidDeck-hand-half-rate.apk`, SHA-256 `c02d56e40802de5c5e9d9750234b24a85462652f472729fbc9696935654f95fb`. The installed hash was verified. The SteamVR driver is unchanged from the tested visual-hold build (`2d7ff8647f210248f6ea4b68e9b05e21ed7ebcc74da601da0f1d854067b7ab82`); the Android SDK bridge and app were rebuilt. Installation preserved app data and occurred with SteamVR stopped. CPU selection and the 200 ms expiry were confirmed across two processes. The glasses were disconnected, so the live half-rate cadence, inference cost, thermal benefit, and controller availability have not been measured. Evidence: `build/hand-half-rate-install.json`. + +At 12.5 Hz, eligible pairs are approximately 80 ms apart. The earlier CPU inference snapshots already took 76–137 ms, so reducing input is not expected to halve total CPU load. It may save image-copy/preprocessing work and reduce inference load when the worker is fast enough, while also increasing frame waiting time and potentially reducing chances to recover a missed detection. It does not guarantee a successful observation or a visible response within 100 ms. A controlled comparison at matching temperatures is required before claiming smoother controllers or less overheating. + +## SteamVR shared-eye image import correction (2026-10-16) + +After the half-rate installation, sessions 31 and 32 hit `VK_ERROR_DEVICE_LOST` approximately 11.7 and 10.8 seconds after READY. DroidDeck's Android process and native 6DoF remained alive; CPU inference, a camera divisor of 2, approximately 25 Hz incoming cameras, and intentionally skipped frames were confirmed. This establishes live operation of the input limiter, but no thermal/performance benefit. The Android crash buffer contained an older VITURE abort in another process, not a new app crash. Evidence: `build/half-rate-crash-state.json`, `build/half-rate-crash-glasses.json`, and `build/half-rate-crash-guest.json`. + +A temporary `DROIDDECK_VR_IMPORT_FORMAT_LIST=0` test ran 49 seconds without device loss with hands disabled. A second test with CPU hands was stopped after the user reported a grey, degraded image. The override is rejected and was not persisted. Restoring the normal import path reproduced device loss in session 35. Neither a successful launch nor removal of image-format metadata is an acceptable fix. + +The normal-path Vulkan trace identifies an external-memory image-description mismatch: SteamVR exports each 1728 by 1080 eye image as format 43 (sRGB), flags `0x8`, usage `0x97`, with view formats 43/37, whereas the presenter imported it as format 37 (UNORM), flags `0x8`, usage `0x85`. Dedicated OPAQUE_FD imports require matching image descriptions. The presenter now retains the exported format, rendering/transfer usage, and view-format list. Presentation selects the corresponding sRGB or UNORM surface format, so an sRGB blit both decodes and re-encodes instead of darkening the display. It rejects incompatible surface encodings rather than silently selecting one, and checks imported-memory binding failures. The existing SteamVR compute-access color fix remains intact. Trace: `build/crash-import-trace/guest.json`. Requirement: [Vulkan dedicated allocation, VUID 01878](https://docs.vulkan.org/refpages/latest/refpages/source/VkMemoryDedicatedAllocateInfo.html). + +The ARM64 build and native regressions pass, including a new regression against the captured SteamVR image description and display-format selection/rejection cases. SDK-enabled and SDK-free APK builds and runtime freshness checks pass. The prior 75 Android tests remain applicable; Android source was unchanged for this graphics correction. Installed SDK-enabled artifact: `build/DroidDeck-shared-eye-format.apk`, SHA-256 `c573169cd46b20b70d704cd92f9f07550d5aa128d0c4300c1c52e635f04958fb`; driver SHA-256 `51dbd719e56c43df6c37edef2d7f426e91183b2b8489285349df19c322090f3b`. Installation preserved the verified calibration, CPU inference, and 200 ms cutoff across two app processes. Logs: `build/shared-eye-format-{native,stage,build,sdkfree,install}.log` and `build/shared-eye-format-install.json`. + +Two subsequent sessions completed 121.9 and 122.7 seconds after READY without a new device-loss event. All sampled head poses were valid, CPU inference stayed active, frame processing advanced, and Android PID 659 remained unchanged. Session 36 initially allocated 1080 by 1080 eyes; its trace confirms identical exported/imported format 43, usage `0x97`, and formats 43/37. Session 37 ran without tracing and allocated the original 1728 by 1080 eyes, removing the lower-resolution confound. Both used a 3840 by 1200 sRGB presentation surface (format 50) and showed approximately 600 frames per ten-second interval after startup. The cumulative compositor log contains older device-loss messages; filtering to the new sessions found no fresh device-loss error. Occasional `WaitForAcquire` warnings remain. Android thermal status reached 4, with current HAL skin temperatures 46.7 and 48.4 degrees Celsius after the respective runs; these are not controlled thermal comparisons. + +These are startup stability checks, not a twenty-minute gameplay/performance pass or proof of every crash's cause. Both test sessions were stopped; all temporary environment overrides and the trace marker were cleared, with calibration and CPU hand settings verified afterward. Evidence: `build/shared-eye-format-live/`, `build/shared-eye-format-relaunch/`, `build/shared-eye-log-audit.json`, and `build/shared-eye-final.json`. + +The user subsequently confirmed normal colors but reported another crash as soon as a hand appeared. Session 38 logged fresh Vulkan device loss at 08:44:25 UTC, about 42 seconds after READY, with a burst of geometry pipeline creation immediately beforehand. Recovery stopped the session, and Android later recorded SIGKILL for the app process; the initial failure was in SteamVR's compositor. The color correction is accepted, but the crash is not fixed. In session 39, the dashboard remained alive with valid head tracking and no detected optical hands, then failed less than four seconds after switching to the existing gamepad controller poses at 20.47 seconds. That reproduces the controller-visibility trigger independently of reconstructed hand coordinates. Evidence: `build/hand-visible-crash/`, `build/hand-visible-exits.txt`, and `build/controller-visibility/`. The preceding two-minute tests did not validate this transition. + +## Visible-controller crash and compositor completion guard (2026-10-16) + +An opt-in diagnostic waited for the compositor's graphics queue after each submission. Session 40 repeated the same optical-to-gamepad-controller transition at 18.01 seconds and stayed alive through 80.94 seconds, with approximately 600 presented frames per ten-second interval. Session 39 without the diagnostic failed less than four seconds after this transition. This supports a GPU synchronization problem in the visible-controller rendering path; it does not establish a specific bad hand sample or thermal cause. An [upstream SteamVR report](https://github.com/ValveSoftware/SteamVR-for-Linux/issues/952) describes premature command-buffer/descriptor-pool reuse, but equivalence to this device's failure is not directly proven. Diagnostic evidence: `build/controller-submit-idle/` and `build/submit-idle-install.json`. + +The shipped experimental guard applies only inside `vrcompositor`. Each `vkQueueSubmit` or `vkQueueSubmit2` waits for its actual completion fence before returning. If SteamVR supplied its own fence, that fence remains attached to the original submission and a following empty submission signals DroidDeck's separate fence. Waiting is bounded to one second; timeout fails the submission path instead of reporting success. The tracker keeps the fence reserved during this wait, preventing the completion worker from resetting/reusing it; a timed-out but submitted fence stays pending until completion or device failure. Other processes retain asynchronous submission. This is a conservative workaround that reduces CPU/GPU overlap, so gameplay frame-time and long-duration acceptance remain required. The temporary `DROIDDECK_VR_SUBMIT_IDLE` probe was removed. + +Native regressions cover both submission APIs, caller-owned fences, submission/marker failures, successful completion, device loss, timeout retention, tracker allocation failure, and bypass outside the compositor. Existing native rendering, spatial, optical-controller, synchronization, and scheduling checks also pass. SDK-enabled and SDK-free builds and runtime freshness checks pass; the prior 75 Android tests apply because Android source was unchanged. Installed APK: `build/DroidDeck-compositor-fence.apk`, SHA-256 `27d44a138d1f6bf6a0698abcd0a48107d31815c8e57a9f7ca07113fabb213195`. Installation preserved the verified calibration, CPU inference, 200 ms hand expiry, and half-rate camera input. Evidence: `build/compositor-fence-{native,stage,build,sdkfree,install}.log` and `build/compositor-fence-install.json`. + +Session 42 repeated the controller-visibility regression on the installed bounded-fence build. Head tracking remained valid; switching to the existing gamepad controller poses at 17.55 seconds did not cause device loss through the final sample at 58.92 seconds. The presenter reported 593–601 frames per ten-second interval, with no late frames in those counters. Optical hands were absent before the switch, so this passes the reproduced synthetic-controller visibility trigger but does not yet validate an actual optical hand appearing. The successful session was left open with CPU optical tracking restored for that check. Evidence: `build/controller-fence-guard/` and `build/controller-fence-guard.log`. + +The built, packaged, and installed Vulkan layers all have SHA-256 `b94d5598131883586fa1d428178f5048669edc40529f3900ec1d0955a5378f89`; no pending or persistent diagnostic environment override remained. The live audit was repeated after the session ended and still confirmed the installed layer, saved calibration, CPU selection, and enabled hand-controller setting. Evidence: `build/compositor-fence-live-audit.json`. + +## Optical appearance confirmed; flicker and pinch remain unresolved (2026-10-16) + +The user confirmed that optical controllers appeared without freezing, but continued to flicker and could not click. This is a successful user-observed optical appearance on the compositor-fence build, not a sustained tracking or interaction pass. The color correction remains accepted. + +A subsequent 16-second CPU baseline in session 43 sampled 2,846 coherent channel snapshots, all with fresh head tracking and none with a valid hand. The requested deliberate open/pinch/release sequence had not yet been confirmed, so absence of hands in this baseline cannot establish detector failure on a visible palm. Diagnostic samples measured 111.7–154.1 ms stereo inference; three observations exceeded the unchanged 200 ms cutoff, with completion ages 204.9–221.5 ms. Android stayed in process 32010 and the same READY SteamVR session. Thermal status was 4, with current HAL skin temperature 51.8 C at the end; this is not a controlled cool-device performance comparison. Evidence: `build/spatial-live-hands-pinch-baseline.json` and `build/pinch-baseline.log`. + +The driver emits `/input/trigger/value` and `/input/trigger/click` from optical pinch. Any invalid/stale hand or head sample releases inputs and disarms gestures until an observed open/released hand, while the visual pose may remain only until its original observation reaches 200 ms. Repeated observation loss can therefore interrupt clicking as well as controller visibility. No deliberate pinch was measured in the new baseline, so this is an explanation of the implemented behavior, not proof of the user's missing-click cause. The next measurement records hand timestamps, validity transitions, trigger strengths, grip, and connection/origin changes without camera images (`build/measure-pinch.py`). No inference thresholds, model, expiry, delegate default, or graphics behavior were changed in this follow-up. + +## Palm continuity and independent gestures implemented (2026-10-16) + +Hand reconstruction now validates each triangulated landmark independently under the unchanged depth and 3-pixel reprojection limits. A controller requires wrist and four palm knuckles; pinch and grip each have separate required fingertips and validity. A rejected finger no longer removes an otherwise accepted palm. Board calibration and distance checks still reject a set containing any invalid point. Protocol version 2 retains the 176-byte layout and carries explicit per-gesture validity bits; old protocol versions are rejected. The native driver releases only the uncertain gesture and requires its observed release before rearming. Unknown finger data cannot arm a click. + +The driver smooths palm translation and rotation with a 15 ms time constant. Three consecutive observations with consistent velocity can enable at most 30 ms / 2 cm of translation prediction. Prediction stops on missing/invalid observations and origin/connection/head changes; the original 200 ms observation expiry is unchanged. Pose filtering never generates or holds gesture input. Native regressions cover independent gesture loss/rearming, old-version rejection, quaternion sign equivalence, prediction bounds, loss holds, expiry, and origin resets. Android regressions cover rejected fingertip versus rejected palm behavior, independent pinch/grip validity, and unchanged metric/reprojection checks. + +Both full and full-palm/lite-landmark models are packaged and SHA-256 pinned. The lighter bundle is reproducible with `tools/build_hand_lite.py` from the documented original models and MediaPipe 0.10.21 metadata tooling. Diagnostics offer temporary model and half/full-input controls; CPU, full model, and half-rate input remain defaults pending a live comparison. An opt-in debug command benchmarks existing saved stereo pairs on CPU without capturing images or publishing replayed hand poses. It clears live hands during replay, closes both temporary detectors, and resumes the selected live model afterward. + +All 259 selected Android tests pass with no failures/errors/skips, including the glasses package and spatial-setup UI. The ARM64 native tests, SDK-enabled and SDK-free Android builds, and runtime freshness checks pass. Installed APK: `build/DroidDeck-hand-reliability.apk`, SHA-256 `38b9b67171b37b0bf80b540da165894ff4cbb24b609ae62edd829ecf618d01e3`. Driver SHA-256: `56b3a3eeaa96160e5cbf740f35b701f935b610417dbbba0aa2965ec109d5418a`. The graphics synchronization layer remains `b94d5598131883586fa1d428178f5048669edc40529f3900ec1d0955a5378f89`. Installation preserved the verified calibration and CPU selection across processes 2843 and 3996. The built, packaged, and deployed driver/layer match; the Android publisher produces a version-2, 176-byte spatial file. Evidence: `build/hand-reliability-{tests,native,stage,build,sdkfree,install,audit}.log` and corresponding install/audit JSON. + +The Fold7 successfully loaded both model bundles using Android Tasks 1.0.0 on CPU. Saved-pair replay ran full/lite/full, each with four warmup and twenty measured pairs, outside SteamVR in the same process. Times below cover stereo inference, excluding model construction, camera acquisition, geometry, publication, and display latency. + +| Saved pair / model | Median inference | p95 inference | Valid palms | +|---|---:|---:|---:| +| Previously detectable pair / full before | 104.95 ms | 107.95 ms | 20/20 | +| Previously detectable pair / lite landmarks | 90.03 ms | 95.54 ms | 20/20 | +| Previously detectable pair / full after | 103.89 ms | 106.20 ms | 20/20 | +| Harder pair / full before | 60.77 ms | 63.88 ms | 0/20 | +| Harder pair / lite landmarks | 62.64 ms | 66.53 ms | 0/20 | +| Harder pair / full after | 62.48 ms | 65.74 ms | 0/20 | + +The lite candidate is approximately 13–14% faster on the detectable static pair. Both models recognize a released pinch/grip and retain their validity on all twenty repetitions; their first measured palm positions differ by about 1.9 mm. This is agreement between models on one static observation, not ground-truth accuracy or stationary-jitter validation. Neither detects the harder saved pair, so reducing landmark cost does not solve missed palm detection. Thermal status ended at 2, with current HAL skin temperature 41.4 C. Evidence: `build/hand-reliability-benchmark-idle.json` and `.log`. + +SteamVR attempts 44 and 45 were suspended by Android with the screen off/lock screen showing before their first displayed frame. Wake/dismiss requests did not dismiss the lock screen. A user unlock is required for the graphics-workload model comparison and a fresh optical open/pinch/release check; neither is counted as a pass. The full model remains the default until that comparison can be completed. The changes are installed as an experimental candidate; reduced live flicker and successful dashboard clicking have not yet been established. + +## Concurrent CPU inference and controller cadence (2026-10-16) + +Left and right CPU inference now run concurrently with separate image buffers and a stable owner for the right detector. Both calls finish before either frame buffer can be reused or either detector closed, including failure and interruption paths. GPU inference remains sequential and opt-in. Controller presentation now approaches the filtered pose on each driver update with a 15 ms time constant, rather than moving only when a new inference result arrives. Missing observations stop prediction and hold the last displayed transform only until its original 200 ms expiry. Gesture validity, input release, head freshness, and connection/origin resets are unchanged. + +All 263 selected Android tests pass without failures, errors, or skips, including four concurrent-worker lifecycle tests. Native spatial regressions cover intermediate render updates, normalized rotations, loss holds, and unchanged expiry. The ARM64 build, SDK-enabled and SDK-free APK builds, and packaged-runtime freshness checks pass. Installed APK: `build/DroidDeck-hand-cadence.apk`, SHA-256 `7df588f0eacdbf4f5ddaae91c511e415b01fe39f37100c012e8f8da3fced52e0`. Driver SHA-256: `195261f27043b260052873a3b083c436457763caa5ebb7bcd1f52708e426bf11`. The graphics layer remains `b94d5598131883586fa1d428178f5048669edc40529f3900ec1d0955a5378f89`. Built, packaged, and deployed binaries match; the spatial channel remains version 2, 176 bytes. Installation preserved CPU selection and verified calibration across processes 13863 and 14542. Evidence: `build/hand-cadence-{native,stage,build,sdkfree,install,audit}.log` and corresponding install/audit JSON. + +A saved-pair comparison ran under SteamVR in one Android process/session using the previously authorized pair `64390821246320`. Each configuration had four warmup and twenty measured pairs. Times cover stereo inference, not acquisition, reconstruction, publication, or display latency. + +| CPU configuration, in test order | Median inference | p95 inference | Valid left palms | +|---|---:|---:|---:| +| Full, sequential before | 202.74 ms | 286.60 ms | 20/20 | +| Full, concurrent | 133.19 ms | 162.33 ms | 20/20 | +| Lite landmarks, concurrent | 104.18 ms | 165.52 ms | 20/20 | +| Full, sequential after | 176.31 ms | 208.47 ms | 20/20 | + +Concurrent full inference had a 24–34% lower median than the surrounding sequential runs. Its first palm position matched the full sequential result exactly; the lite result differed by about 1.9 mm. All repetitions retained released pinch/grip validity. These are repeated static-pair results, not physical accuracy, dynamic coverage, or clicking acceptance. Android thermal status was 4 throughout, with current HAL skin temperature increasing from 48.8 to 50.6 C. The ordered test was not temperature controlled. The lite model's lower median did not improve its p95 over concurrent full inference; the full model remains the default. Evidence: `build/hand-reliability-benchmark-steamvr-parallel.json` and `build/hand-cadence-benchmark.log`. + +For the live tests, the user confirmed an open left palm approximately 12–18 inches away, moving slowly side to side. Each sample lasted 16 seconds. All coherent head samples were fresh. The sequential baseline used session 50; both concurrent-input samples used process 14542 and session 51 without a restart. + +| Live configuration | Coherent reads | Reads with fresh left hand | Distinct left observations | Left arrival age, median / p95 | Sampled inference median | +|---|---:|---:|---:|---:|---:| +| Previous sequential CPU, 12.5 Hz input | 2,959 | 29.47% | 113 | 160.16 / 196.23 ms | 117.03 ms | +| Concurrent CPU, 12.5 Hz input | 2,941 | 91.77% | 186 | 74.94 / 84.81 ms | 66.06 ms | +| Concurrent CPU, 25 Hz input | 2,932 | 64.36% | 152 | 91.93 / 109.69 ms | 62.55 ms | + +The freshness percentages measure sampled shared-channel availability; they are not the acceptance target's percentage of valid camera observations and cannot pass or fail that 95% gate. Arrival age measures the original observation's age when first seen by the channel monitor, not externally measured physical-motion-to-visible-controller latency. Natural hand motion, detected hand count, and temperature were not held constant. Both cameras often reported two hands during the requested left-palm test, so right-channel availability is not evidence of verified right-hand identity or aiming. Thermal status was 4, with HAL skin temperatures of 47.5–47.7 C for the baseline, 50.5 C for limited input, and 50.7–50.8 C for full input. These short, ordered samples support further testing of the candidate, not a causal attribution of the entire improvement or a general conclusion that full-rate input is worse. Full-rate input did not improve observed availability in this comparison; the original 12.5 Hz input cap was restored. The SDK cameras continue at approximately 25 Hz. + +The user reported improved but still choppy motion, a reversed right-controller pointing direction while the left behaved as expected, and less flicker with both hands detected than with one. Right-hand orientation correction and investigation of the one-hand/two-hand difference are in progress; neither is validated by this candidate's measurements. No new camera images were saved. Session 51 later suspended and exited with status 0; a subsequent audit found session 52 READY, CPU/full/concurrent inference, the 12.5 Hz cap, verified calibration, and no temporary graphics overrides. Evidence: `build/spatial-live-hands-choppy-baseline-confirmed.json`, `build/spatial-live-hands-cadence-{half,full}.json`, `build/hand-input-comparison.json`, `build/hand-cadence-summary.json`, and `build/hand-cadence-audit.json`. + +## Right-hand orientation and camera-clock continuity (2026-10-16) + +The user's report of a reversed right controller exposed a handedness-independent palm basis. The right hand now reverses its lateral axis before constructing the rotation, giving mirrored palms the same normal convention while preserving the existing left mapping and wrist-to-finger direction. Both live reconstruction and saved-pair replay pass an explicit hand side. Tests cover mirrored palms, 180-degree and arbitrary rotations, camera-to-world transforms, and unchanged gesture values and timestamps. These tests verify the mathematical correction; the user subsequently confirmed that the right-controller orientation is correct on the installed build. Measured aiming accuracy across poses remains pending. + +The one-hand/two-hand flicker difference has a plausible processing explanation: the [upstream MediaPipe video graph](https://github.com/google-ai-edge/mediapipe/blob/master/mediapipe/tasks/cc/vision/hand_landmarker/hand_landmarker_graph.cc#L259) repeats palm detection until the previous tracked hand count reaches the configured maximum. DroidDeck requests two hands. Per-camera inference durations and current/previous raw hand counts are now reported separately from confidence-filtered counts so this hypothesis can be measured. No hand-count restriction, confidence reduction, or synthetic second hand was introduced. + +A separate clock defect reset camera synchronization whenever the worker skipped more than 200 ms of source frames, even when host and source clocks advanced consistently. A processing stall could therefore add another 16 observations of warmup (roughly 1.3 seconds at 12.5 Hz). The mapping now survives an aligned long gap; offset discrepancies above 20 ms, invalid timestamps, or nonmonotonic source/receipt times still require warmup. Existing short-gap rolling-minimum/p90 jitter handling is retained. Six regressions cover 240 ms and one-second gaps, resets, offset changes in both directions, jitter boundaries, and recovery. Hand observation expiry remains 200 ms and head expiry remains 100 ms. + +All 271 selected Android tests pass without failures, errors, or skips. SDK-enabled and SDK-free builds and packaged-runtime freshness checks pass. Native code is unchanged from the tested cadence build. Installed APK: `build/DroidDeck-hand-continuity.apk`, SHA-256 `46b99d939e5c7063840ae669128b40ba60a794e62a30c1a14f38da27362d2855`; driver remains `195261f27043b260052873a3b083c436457763caa5ebb7bcd1f52708e426bf11` and the graphics layer remains `b94d5598131883586fa1d428178f5048669edc40529f3900ec1d0955a5378f89`. The installed APK hash matches, and processes 29580 and 30045 both initialized CPU inference and loaded the verified calibration. CPU/full/concurrent inference and the 12.5 Hz input cap remain selected. No new images were captured. Evidence: `build/hand-continuity-{build,sdkfree,stop,install}.log` and `build/hand-continuity-install.json`. Subsequent live results follow; sustained smoothness acceptance remains pending. + +SteamVR reopened as session 54 and reached READY with valid head tracking. A live audit verified the built, packaged, and deployed driver/layer hashes, the version-2 spatial channel, saved calibration, CPU/full/concurrent inference, the 12.5 Hz cap, and the new per-camera diagnostic fields. This is an installation/startup check, not the pending deliberate one-hand/two-hand comparison or a visual orientation pass. Evidence: `build/hand-continuity-launch.log`, `build/hand-continuity-audit.log`, and `build/hand-continuity-audit.json`. + +## Live hand-count comparison and remaining startup delay (2026-10-16) + +The subsequent 44-second live comparison retained Android process 30045 and SteamVR session `2026-10-16-54-steam`. All 8,146 coherent head reads were fresh; the left hand was fresh in 97.30% of channel reads. The right hand was introduced after the left, and both cameras reported two hands from approximately 13 seconds. Consequently, the nominal first-20-second/remaining-test stages are not clean one-hand/two-hand windows. The whole-run right-hand availability of 71.00% includes the period when it was absent and must not be interpreted as right-hand detection accuracy. + +Per-camera timings were grouped by each detector's previous raw hand count, which is the count relevant to the upstream video graph's palm-search decision. The smaller count group contained eight diagnostic snapshots per camera, and the two-hand group contained nineteen. + +| Camera | Previous raw hands | Diagnostic samples | Median inference | p95 inference | +|---|---:|---:|---:|---:| +| Left camera | 1 | 8 | 73.36 ms | 80.27 ms | +| Left camera | 2 | 19 | 55.96 ms | 69.10 ms | +| Right camera | 1 | 8 | 71.94 ms | 87.04 ms | +| Right camera | 2 | 19 | 53.15 ms | 65.69 ms | + +The observed per-camera medians were approximately 17–19 ms lower with two previously tracked hands. This is consistent with the extra palm-search work described above, but the ordered, natural-motion test does not isolate that work from pose, visibility, or workload changes. Thermal status remained 4, with HAL skin temperature 50.7 C at both endpoints. These internal inference timings do not measure physical-motion-to-visible-controller latency. The 97.30% sampled left-channel availability is also distinct from the required 95% valid camera-observation rate; neither acceptance gate is established by this run. No new camera images were saved. Evidence: `build/hand-count-live.json`, `build/hand-count-live.log`, and `build/hand-count-summary.json`. + +The user confirmed the right-controller orientation correction and described single-hand tracking as smoother and more reliable, but said it takes a while after SteamVR starts to become smooth. Startup choppiness remains unresolved. This measurement did not isolate startup behavior, and it does not establish a warmup, thermal, synchronization, or graphics cause for that remaining delay. Longer controlled runs, an observation-based coverage measure, external latency measurement, and deliberate optical interaction checks are still required. + +The user clarified that startup choppiness lasts about a minute or longer after the dashboard appears. Both CPU detectors, camera synchronization, and verified calibration were already active in process 30045 before SteamVR launched, so initial model loading alone does not explain the delay. Session-54 compositor logs, aligned to their Denver timestamps, record 138 shader-pipeline creations during seconds 20–69 after the launch request and another 12 during seconds 120–129. This identifies ongoing graphics initialization as a plausible source of CPU contention, not a measured causal explanation of all startup stutter. The current session remained READY; its later presenter counters were about 600 frames per ten seconds. No matched `vkerror`, device-loss, fatal, or segmentation messages appeared in the filtered session window, although a `WaitForAcquire` timeout remains. No startup scheduling, cache, graphics, or loading-screen changes were made. A correlated startup trace of hand latency and CPU/GPU workload is still needed. Evidence: `build/hand-startup-review.json` and `build/hand-continuity-install.json`. + +## Gesture, single-hand scheduling, and motion update (2026-10-16) + +The next candidate keeps CPU/full-model/concurrent stereo inference. Calibrated stereo palm reconstruction is unchanged; pinch and finger closure now use agreement between each camera's image landmarks. Invalid or conflicting finger geometry clears the affected gesture, and the driver still requires an observed release before rearming it. This avoids making a valid palm depend on successful triangulation of every fingertip, without claiming that a lost finger is released. + +CPU inference now retains separate one-hand and two-hand video trackers for each camera. Three consistent stereo observations enable the one-hand path; a two-hand search is due after 240 ms, and loss or ambiguous handedness returns to search. The selected bank's raw counts and hand limit are reported. Both per-camera tasks finish before images or detectors are reused or destroyed. GPU remains optional and serial. The adaptive copy gate starts at 500 permille of source callbacks (12.5 Hz with 25 Hz cameras), with 600/800 permille available only after eight consecutive healthy samples meet processing and age thresholds. Slow discovery samples can prevent an upshift; the presence of this controller is not evidence of achieving 15 or 20 Hz. Camera capture and vendor head tracking retain their normal rate. + +The driver removes the additional observation-level low-pass and retains one 15 ms rendering correction. Stable translation advances from the time a result reaches the driver, bounded by 80 ms and 2 cm, instead of exhausting prediction during inference. Capture timestamps still control velocity and expiry. Explicit loss freezes the displayed pose, immediately releases invalid inputs, and preserves the 200 ms hand expiry and 100 ms head expiry. This is bounded motion estimation, not additional measured hand observations. + +Validation: all 306 selected Android tracking/UI tests pass, with no failures, errors, or skips. The ARM64 VR build and native regressions pass, including delayed/jittered observations at 4 ms driver ticks, stops, reversals, outliers, quaternion normalization, exact loss freeze, expiry, and origin/connection changes. Fractional camera-gate regressions pass with strict compiler warnings. SDK-enabled and SDK-free Android builds, 13 runtime-preparation tests, and runtime checksums pass. The loading/first-frame flow and graphics color path were not changed in this update. + +Installed on the existing Fold7 as `build/DroidDeck-hand-smoothness.apk`, final SHA-256 `9508370c42870e60a0070abf61d99792df581436f802049b068b96eba95fa027`; driver SHA-256 `52a96238afedf68c38866588db8225d2bd82450ed13635a5673ca7f9e0c6835b`. Android requested USB access after the first candidate installation; the user accepted it. Final verification matched the installed APK hash and confirmed CPU selection, automatic rate selection, scheduled single-hand tracking, and the existing verified calibration in two separate app processes (6139 and 6989). CPU inference initialized in 6139; process 6989 was initially waiting for valid head tracking, so its configured CPU delegate was not yet initialized. The saved 25-view calibration and distance check were retained. Evidence: `build/hand-smoothness-{native,stage,final-build,sdkfree,runtime-tests,install}.log` and `build/hand-smoothness-install.json`. Deliberate moving-hand, grab/release, external latency, and sustained game-performance checks remain required. + +Saved-pair replay of the previously authorized capture `64390821246320` compared parallel full-model search, scheduled full-model tracking, scheduled lite-model tracking, then a repeated full-model search baseline. Each row measured 20 frames after four warmup frames. The scheduled rows used the one-hand path for 13 of those frames. All rows retained a valid left palm and valid released pinch/grip in all 20 measured frames; the source image is a stationary open palm, so this does not validate moving hands or pressing gestures. + +| Workload | Full search median / p95 | Scheduled full median / p95 | Repeated full search median / p95 | +|---|---:|---:|---:| +| App idle | 70.93 / 76.19 ms | 36.74 / 74.04 ms | 71.28 / 75.77 ms | +| SteamVR | 91.48 / 99.26 ms | 46.92 / 94.71 ms | 86.39 / 100.62 ms | + +Scheduled lite-model medians/p95 were 25.41/67.04 ms idle and 40.26/86.77 ms under SteamVR. The full model remains selected because a repeated static image cannot establish the lighter model's live tracking or gesture accuracy. The SteamVR comparison retained process 333 and session `2026-10-16-57-steam`; thermal status was 4 and HAL skin temperature rose from 49.5 to 51.0 C. These short ordered runs show lower typical inference cost on this saved pair, while discovery-frame tail latency remains. They do not establish external motion-to-controller latency, sustained game frame time, or reduced thermal throttling. No new camera images were captured. Evidence: `build/hand-reliability-benchmark-smoothness-{idle,steamvr}.json`. + +The final adaptive policy uses average processing cost for normal budget changes so occasional discovery frames do not veto otherwise sustained headroom. Any single processing cost at least 80 ms, observation age at least 140 ms, or invalid tracking falls back to 12.5 Hz. Regression tests verify that a repeating 36/36/74 ms pattern can select 15 Hz but not 20 Hz, while continuous 70 ms work stays at 12.5 Hz. This change does not assert that the observed SteamVR workload qualifies for a higher rate. + +Final deployment audit: SteamVR session `2026-10-16-58-steam` reached READY with a first frame and valid head tracking. Built, packaged, and deployed driver hashes match; the unchanged graphics-layer hash is `b94d5598131883586fa1d428178f5048669edc40529f3900ec1d0955a5378f89`. The version-2 spatial channel and verified calibration were present, with no temporary environment overrides. CPU/full/concurrent inference, scheduled discovery, and adaptive input were active. The audit snapshot showed one accepted palm with valid pinch/grip geometry, the one-hand inference bank, 47.10 ms stereo inference, approximately 25 Hz source cameras, and a 500-permille input limit. A single snapshot does not demonstrate reliable movement or actual pinch/grip presses. Evidence: `build/hand-smoothness-{launch,audit}.log` and `build/hand-smoothness-audit.json`. + +## Stationary jitter and persistent input release (2026-10-16) + +The user reported stationary controller bounce and a dashboard drag that remained attached after a controller flickered and the hand returned open. The original 16-second reproduction recorded 2,905 coherent channel reads with fresh head tracking throughout. The right hand was fresh in 812 reads; 64 distinct poses were recorded. Right-hand transitions included five samples above the trigger-click threshold, 63 valid released-grip observations, and no pressed grip. Both hands were invalid at the end of the sample. This does not by itself locate the missing dashboard release: the original driver lacked per-input publication diagnostics. Evidence: `build/spatial-live-hands-sticky-grab-baseline.json`. + +Inspection of the installed Vive compositor binding showed that dashboard left-click/drag uses the trigger, with grip mapped to Back. The installed dashboard `GrabHandle` attaches the panel to the initiating hand and clears that attachment on a window mouse-up event; it has no tracking-loss cleanup in that component. A missing mouse-up is consistent with the report, but the exposed code does not prove that native laser-mouse processing discards releases when a pose becomes invalid. Resource evidence: `resources/config/vrcompositor_bindings_vive_controller.json`, SHA-256 `16f19a170608c9b3450e7fc980644220a5bd3a34e1bb88050e65f51c7600a2d1`, and `resources/webinterface/dashboard/chunk~8012d0c89.js`, SHA-256 `8a529bd96141480a18efa44b912a81a1e27ac1bf8bae6b2ab8945ebaf6da2e73`. No SteamVR resource was modified. + +The driver now stabilizes translation and rotation independently against fixed stationary anchors, holding within 3 mm and 1 degree. Breakaway uses the existing 15 ms rendering correction; it does not subtract a dead-zone distance from every observation. Returning to a hold requires 240 ms inside tighter 1.5 mm / 0.5-degree bounds and a check against sustained directional drift. Position prediction stops while anchored. Native tests cover still jitter, quaternion sign flips, accumulated slow translation/rotation, fast breakaway, settling, and the existing delayed-motion and loss behavior. These thresholds are candidates; stationary jitter and fine aiming still need hardware confirmation. + +A confirmed latest-snapshot race could hide a transient invalid hand/head observation from the driver. Protocol version 3 retains the 176-byte layout and uses the offset-36 word for four independent 8-bit loss counters: left trigger/grip, then right trigger/grip. Loss remains visible in subsequent snapshots even if the invalid snapshot was overwritten. Head gaps clear cached hands, captures preceding head loss cannot rearm inputs, and expiry/invalid-gesture transitions update only the affected counters. The driver clears matching input state on counter changes, rejects old or duplicate observations for rearming, and detects observation gaps beyond 200 ms. It publishes released trigger scalar/click and grip before pose loss, clears inputs before deactivation, and logs state/error transitions for hardware verification. No synthetic presses or fresh poses were introduced. Versions 1 and 2 are rejected, so the Android and driver binaries must be updated together. + +All 317 selected Android tests and the native regressions pass. New tests deliberately skip invalid snapshots, preserve independent trigger/grip state, reject stale release observations, verify publication ordering, and retry rejected OpenVR component writes. SDK-enabled and SDK-free Android builds and runtime checksum verification pass. Installed APK: `build/DroidDeck-hand-stability.apk`, SHA-256 `0e3f4a140e36eb48e91f5937748b0e10afe3491a0236484b21e9a3faa3ca6766`; driver SHA-256 `cca5723189a77cde606d11afd55d80567e7f72398e3f50e706bee164cb91eb5f`. Calibration survived two app processes (17259 and 17867); CPU initialized in the latter. SteamVR session `2026-10-16-60-steam` reached READY with a first frame. Evidence: `build/hand-stability-{native,stage,build,sdkfree,install,launch,audit}.log` and `build/hand-stability-{install,audit}.json`. End-to-end dashboard release and visible stationary improvement remain pending the deliberate post-installation check. + +## Outstanding acceptance + +### Investigation and shared base calibration (2026-10-16) + +The phone's current verified 640×480 pinhole profile was exported directly over authorized ADB. Its 1.1209395390660726-px fit, lens coefficients, stereo transform, and camera-to-head transform are now bundled unchanged as `app/src/main/assets/calibration/luma-ultra-640x480.json`, with the source device identifier removed. Asset SHA-256: `d160f0c81d0328255f9afa69bc61505e5aa2988a9bb7a9faaeb611598eee7faa`. A matching personal profile takes precedence; new or unidentified Luma Ultras use this base for experimental tracking. Shared geometry is not falsely marked validated on other devices. UI and diagnostic status identify the shared base separately from individually verified profiles. + +Hand tracking now displays **Experimental** throughout the relevant controls and setup status. Per-observation diagnostics distinguish detection/association failures, missing palm landmarks, palm width/basis/motion rejection, stale data, and tracking loss. Connection-lifetime counters retain independent palm, trigger, and grip acceptance/loss evidence without counting repeated status polls. Tracking and input thresholds are unchanged. The historical trace analysis and prioritized improvement experiments are recorded in `luma-hand-tracking-investigation.md`; no new moving-hand or game-usability pass is claimed. + +All 388 focused glasses and setup/UI tests pass, including the new calibration selection and diagnostic-counter regressions. Exact geometry comparison against the phone export passes. The SDK-enabled APK builds with runtime freshness verification enabled. After the concurrent upstream Joy-Con merge, the already rebuilt VR outputs were validated against current source/header/configuration hashes and restaged with the updated helper scripts; unrelated prepared binaries retained their hashes. All 150 packaged runtime outputs match the resulting manifest. The packaged base calibration matches its source exactly, and the APK includes the new diagnostics. Artifact: `build/DroidDeckXR-luma-experimental.apk`, SHA-256 `11235040ad8c34abfd23482beb552fb09db4d9429703fbc8d7c5090b98da940e`. Runtime provenance is in `build/luma-hand-runtime-restage-20261016/provenance.json`. This change has not been installed on the phone. Logs: `build/luma-investigation-tests.log`, `build/luma-investigation-build.log`; metadata: `build/luma-investigation-validation.json`. The source phone profile backup stays in ignored `build/luma-ultra-phone-calibration-20261016.json`. + +| Gate | Current evidence or blocker | +|---|---| +| Measured head axes and meter scale | Pending measured translation, leaning and crouching | +| Floor and separate origins on hardware | Automated math passes; physical crouched recenter and picture switching remain pending | +| Screen anchoring and plane crossing | Shader and parameter tests pass; visual movement and plane-crossing checks remain pending | +| Camera image orientation | Upright 640 by 480 images and visible palms verified in one authorized diagnostic pair | +| Calibration quality | 25-view set passes fit/alignment checks with 1.12094 px held-out reprojection error. Repeated distance check passed: 12.13 inches measured against 12.00 selected; SDK-identified verified profile survives app restarts | +| Hand pose and aiming | User confirms corrected right-controller orientation and smoother, more reliable single-hand tracking. Latest 44-second comparison had 97.30% sampled left-channel availability; startup choppiness, measured aiming accuracy, and sustained continuity remain pending | +| At least 95% valid hands at 30–80 cm | Camera-observation acceptance rate not measured; sampled channel availability above is a different metric | +| At most 5 cm hand error and 2 cm jitter | Not measured | +| External p95 controller latency below 100 ms | Not measured | +| Hardware input release and reacquisition | State-machine tests pass; user-requested 200 ms hand expiry / 500 ms reacquisition not measured physically | +| Twenty-minute game performance | No controlled baseline or CPU/GPU comparison | +| Dashboard and Angry Birds VR interactions | Not validated with optical controllers | +| Occlusion, crossed hands, lighting and thermal load | Pending | +| Physical USB reconnect during inference | Generation/lifecycle guards implemented; no calibrated-inference unplug test | + +The user confirmed corrected colors, optical controllers appearing without a freeze, corrected right-controller orientation, and smoother, more reliable single-hand tracking. The latest timing comparison is consistent with additional palm-search work when only one hand is tracked. Startup choppiness remains unresolved, with no established cause. A confirmed open/pinch/release sequence is still needed to distinguish missing/expired observations from gesture recognition or input-path failures. Full palm detection with the lite landmark model remains an experiment; the current full model stays selected. Controlled temperature-matched SteamVR measurements, right-hand correspondence across poses, and measured aiming validation remain necessary. The compositor guard passed the reproduced gamepad-controller visibility trigger; long-duration and GPU-inference stability remain unvalidated. Delegate and process identity must be checked across each measurement because graphics recovery recreates the hand engine; it now selects CPU by default and discards any temporary GPU override. The saved calibration no longer needs repeating after an identified-device reconnect. The combined feature must remain experimental until hand tracking and the remaining acceptance measurements pass. Native 6DoF availability alone is insufficient for release. + +## Fork migration and latest feedback (2026-10-16) + +The post-installation check did not establish a fix: the user could not start the dashboard drag and reported stationary controller jitter about the same. Dashboard interaction, release after tracking loss, and visible stationary stability remain unresolved. + +At the user's request, the 63 uncommitted XR files were moved from `C:/Users/conno/Desktop/DroidDeck` to `C:/Users/conno/Desktop/DroidDeckXR` on branch `feat/3dfixes-6dof`. A three-way merge preserved the fork's resolution and menu changes; 13 non-overlapping fork files remained unchanged. Original files and patches from both checkouts are preserved in `build/xr-migration-20261016`. The source checkout is clean after hash-verified removal of the migrated edits. + +The merged fork passes 373 selected Android tests and 13 packaging tests, plus SDK-enabled and SDK-free builds. The existing tested ARM64 VR outputs were reused after validating their source, SDK-header, configuration and binary checksums; they were not rebuilt during migration. All 133 prepared runtime outputs match the SDK-enabled APK. The new APK is `build/DroidDeckXR-migrated-sdk.apk`; it has not been installed. See `build/xr-migration-verification.json` for hashes and the retained historical runtime-provenance boundary. Subsequent work belongs in DroidDeckXR. + +## Connected-device isolation review (2026-10-16) + +Reviewed the outstanding DroidDeckXR changes together, including optical and Joy-Con tracking, calibration, display-mode routing, recovery overlays, graphics fixes, RGB diagnostics, and build/runtime provenance. Ultra controls now require a controllable, connected device whose Carina capability was confirmed by the VITURE SDK. Model names and saved Ultra preferences alone do not enable them. The experimental position/hand/Joy-Con controls, floor/eye-height setup, 6DoF label, calibration activity, recovery overlay, and RGB diagnostic entry follow this capability. Calibration closes when the connection disappears, and launching it directly without an Ultra is rejected. + +Saved Ultra controller preferences no longer suppress the phone-camera permission or controller path for other glasses. Routing is refreshed on device changes as well as setting changes. Opening a non-Carina link clears the retained spatial-channel mode; temporary Ultra tracking loss still invalidates poses without silently switching to fixed-height legacy tracking. Tests cover disconnect, reconnect, unconfirmed model names, non-Ultra VITURE, XREAL and RayNeo states, rejected mode changes, and the native-channel flags. + +The optional UVC directory now accepts an explicitly empty Gradle override, requires its license files before packaging, and is included in the local native-source preparation audit. All 456 selected Android tests pass with no failures, errors or skips. An earlier Compose calibration timeout passed in isolation and in the final complete selection without changing the test or product behavior. The ARM64 VR rebuild and native regressions pass. Linux packaging/helper tooling reports 47 passing tests; two shader compilation tests were skipped because glslangValidator is unavailable (this change set does not modify shader source or its generated header). + +Both the SDK/UVC-enabled and SDK/UVC-free Android builds pass, and all 150 prepared runtime outputs match each APK. Package inspection confirms the enabled build includes the optional libraries and UVC notices, while the disabled build contains none of those optional libraries. Artifacts: `build/DroidDeckXR-ultra-reviewed.apk` (SHA-256 `a01706d56b876c2fec7b9386d33e9dc66854ead66b48a1392c492bde7c3591d3`) and `build/DroidDeckXR-ultra-reviewed-sdkfree.apk` (`6ce45e225a37c74355eb7d65e76b2ac63be7064ec24cbe389e006452e0e27390`). Results and logs are retained under `build/ultra-review-*`, including `build/ultra-review-verification.json`. + +This review did not install a new package or repeat hardware acceptance. The existing dashboard interaction and stationary jitter reports remain unresolved; the combined tracking feature remains experimental. diff --git a/docs/development/luma-spatial-tracking.md b/docs/development/luma-spatial-tracking.md new file mode 100644 index 0000000000..26ecaf00fc --- /dev/null +++ b/docs/development/luma-spatial-tracking.md @@ -0,0 +1,96 @@ +# Luma Ultra spatial tracking + +For supported glasses across brands, feature levels, and app-wide setup, see the +[smart-glasses support matrix](../smart-glasses-support.md). + +This is an experimental implementation of native Luma Ultra head tracking, positional virtual screens, and optical SteamVR controllers. Positional tracking, bare-hand controllers, and Luma Joy-Con tracking all default to off and are grouped under Experimental. Combined release acceptance remains pending until the calibration, accuracy, latency, gameplay, and sustained performance targets below have been measured on hardware. + +## Build and setup + +Luma Ultra now includes a shared starting calibration exported from the user's verified Fold7 profile on 2026-10-16. The bundled `calibration/luma-ultra-640x480.json` contains the original lens, stereo, and camera-to-head geometry without the source glasses' serial identifier. It applies only to the SDK-confirmed Luma Ultra primary `left0/right0` pair at 640 by 480. Matching saved device calibration takes precedence, including an unfinished personal fit that still requires distance validation. Missing, corrupt, or foreign profiles fall back to the model base; unknown serials can also use the base. + +The base enables experimental hand tracking without requiring every user to repeat board collection. It is not marked individually verified on other units. Tracking and setup show **Shared Luma Ultra calibration** while it is in use; diagnostics distinguish `calibrationSource` (`luma-ultra-base`, `device`, or `none`) from `calibrationVerified`. The existing `calibrated` availability field is true for either the base or a verified personal profile. The following board steps are optional refinement for a new device using the base; a newly calculated personal profile still needs the unchanged distance check before use. A successful distance check saves the profile for the connected identified glasses. Source validation does not establish manufacturing consistency or aiming accuracy across other units. + +Use the existing optional `droiddeck.vitureSdk` local property with the external VITURE Android SDK 2.4.0. No vendor headers or libraries are checked into the repository. `-PvitureSdkDir=` explicitly builds without the SDK. The ordinary runtime freshness checks remain enabled. Rebuild the ARM64 VR components with `tools/vr/build_windows.py`; its manifest includes `spatialpose_shm.h`. + +The hand pipeline pins MediaPipe Tasks Vision 1.0.0, OpenCV 4.13.0, and the model and SHA-256 recorded in `app/src/main/assets/models/hand_landmarker.provenance.json`. Both Gradle and the inference worker verify the model checksum. CPU inference, the full model, concurrent camera inference, scheduled hand discovery, and automatic input-rate adjustment are the defaults, including after app restarts, reconnects, and provider restarts. **Show diagnostics → GPU hand inference** temporarily enables GPU until the next tracking restart; GPU remains experimental because SteamVR restarts and Vulkan device loss were observed during testing. Diagnostics report the selection as `handGpuEnabled` and the initialized detectors as `handInferenceBackend`; `not initialized` means detector startup has not completed. Sustained performance acceptance remains unresolved. + +Hand input starts by copying 500 permille of stereo callbacks, approximately 12.5 pairs per second at the SDK's documented 25 Hz camera rate. On CPU, automatic adjustment can raise this to 600 or 800 permille (about 15 or 20 Hz) only after eight consecutive valid observations have sufficient processing and freshness headroom. Promotion requires average processing at most 55 ms and observation age at most 110 ms for 15 Hz, then at most 40 ms and 90 ms for 20 Hz. A moving average allows occasional scheduled discovery frames while preserving a sustained processing budget. An average above the selected period reduces the rate; any single processing cost of 80 ms or observation age of 140 ms immediately returns it to 500 permille. Tracking failure and detector resets also return it to 500. This policy requests more input only when processing can accommodate it; it does not guarantee that many completed or valid hand updates. + +Skipping happens before copying camera pixels into DroidDeck, so skipped pairs also avoid JNI transfer, preprocessing, and inference. The SDK exposes no tracking-camera rate setter: sensor capture, vendor VIO, pose callbacks, and head polling retain their normal rates. Calibration collection, distance checks, explicit diagnostic capture, and preview-only operation use full-rate input. Diagnostics keep incoming `cameraHz` distinct from `cameraCopyPermille`, `rateLimitedFrames` (intentional skips), and `dropped` (eligible pairs replaced while the worker is busy). The compatibility field `cameraFrameDivisor` is 2 at 500 permille, 1 at 1000, and 0 for intermediate fractions. The bounded latest-pair queue and original capture timestamps remain intact. **Automatic hand input rate** can be disabled to expose the manual half/full-rate switch; both choices reset with tracking. GPU uses that manual preference and does not adapt. Thermal, latency, and gameplay benefits require hardware comparison. + +1. Connect a Luma Ultra and grant its existing USB permission. Spatial controls appear only after the SDK identifies the device as Carina. +2. Enable **Positional tracking — experimental**. This restarts the provider in 6DoF mode. Switching picture modes does not restart it. +3. Enter the current seated or standing eye height (shown in centimeters and feet/inches) and choose **Set floor from current height**. Normal VR recentering then preserves that floor, including while crouched. After reconnecting or explicitly restarting tracking, accept the new origin through setup/recenter. A recenter request during lost/stale tracking or recovery remains pending until 250 ms of fresh, steady poses arrive; repeated taps are unnecessary. The pending request is canceled on disconnect. +4. Open **Stereo camera setup and diagnostics → Open setup**. The page uses the selected DroidDeck theme and app scale, with a single compact Back/title row so the controls have room to scroll in landscape. Check head tracking and camera synchronization first; capture controls become available when both are ready. Expand **Show diagnostics** for frame rate, frame age, dropped frames, processing time, and recovery tools. +5. Print the 5 by 7 ChArUco board at actual size. Measure a square: it must be 30 mm (approximately 1.181 inches). Keep the board stationary and capture at least 24 sharp views by moving and rotating the glasses, covering the image center and edges. Include both yaw and pitch, roll, and varied distances. If the underlying tracking frame changes, start a new capture set; software recentering in an unchanged frame preserves the set. +6. Calculate calibration. Accepted captures confirm board detection, not alignment quality. The fitter compares pinhole and fisheye models on held-out views. It rejects poor stereo reprojection, an implausible baseline, insufficient rotational diversity, and inconsistent stationary-board alignment. Turning and tilting the glasses is required; pause before each capture. If the board stayed fixed but alignment varies beyond 5 cm (about 2 inches), the head-tracking frame may have shifted during collection. Wait for steady tracking and start a new set; do not remove the quality gate to accept the old one. +7. Start with **12 in (30.48 cm)** or **30 cm (11.81 in)** under **Measured distance**; **20 in** and **50 cm** remain available. The closer settings make the small printed markers easier to resolve in the 640 by 480 tracking cameras. Show the complete board with its center exactly the selected distance from the left camera, then choose **Validate distance**. You can hold or support the glasses without wearing them. Progress and the result appear beside this button. The count refers to detected checkerboard intersections, not the paper's edges; a fully visible but small or blurred board can still have too few detections. Validation detects corners in the original images, then corrects those coordinates for lens distortion before triangulating, avoiding marker blur from resampling the images. Rejected stereo geometry reports that depth could not be measured; a valid reconstruction shows measured and selected distances in both units. Each imperial or metric choice uses its exact distance. The complete 24-corner board and physical-distance check within 5 cm (about 2 inches) are still required before a newly fitted personal profile becomes usable. Profiles are keyed to the SDK board-serial SHA-256 identifier (falling back to a nonblank Android USB serial), dimensions, and format version. Verified profiles reload automatically after an app restart or reconnect to the same identified glasses. If neither identifier is available, profiles remain connection-local. +8. Enable **Hand controllers — experimental**. Present an open hand first so inputs can arm. Aim the virtual controller at the target, pinch thumb and index finger together to press the trigger/click, then separate them to release. Moving the SteamVR dashboard by its handle uses this same pinch-and-release action. Keep the other fingers open when only clicking; curling the middle, ring, and little fingers activates the separate grip input, which the installed Vive dashboard binding maps to Back. Games can use grip for holding objects. After tracking loss, open the hand again before another press. Gamepad sticks supply locomotion and turning; buttons retain the Vive-compatible mapping. External VR controllers retain precedence. + +The diagnostic capture button saves one stereo pair and metadata to the app-private `files/spatial/captures` directory. Merely opening diagnostics does not save images. Calibration profiles stay in `files/spatial`. A brief missed hand detection holds the last observed controller transform only until its original observation reaches 350 ms old. Input freshness remains limited to 200 ms. Pinch and grip release immediately on a detected miss and require an observed release before rearming. The hold does not extrapolate motion, refresh timestamps, or substitute a gamepad pose. Head tracking loss, origin/connection changes, disconnects, and controller-mode changes clear it. Gamepad menus and locomotion remain available during optical hand loss. Switch hand controllers off explicitly to return to gamepad-positioned controllers. + +Accepted board landmarks and their capture-time head poses are saved separately in app-private `files/spatial/*-captures.json`, without camera images. A matching SDK or USB device identity and image geometry allow automatic recovery for recalculation. Restored observations cannot be appended to a new tracking frame; start a new set to capture again. Devices without either stable identifier keep a session-labelled diagnostic backup and require explicit developer recovery onto the same physical device. They do not automatically reuse another connection's unidentified capture set or personal calibration; they can still use the bundled model base. + +The vendor SDK working directory is `noBackupFilesDir/viture`. Android can evict `cacheDir` during a live session, so active tracking files must not depend on that location. The SDK initializes its own files in the new directory on the next provider start; existing printed-board calibration profiles remain in `files/spatial`. + +## Coordinates and lifecycle + +`SpatialPose` uses meters and right/up/back OpenGL coordinates. Quaternions are normalized xyzw internally; SDK arrays are position followed by wxyz. Legacy orientation conversion and the 128-byte head-pose channel remain intact. The session coordinator survives `HeadTracker` recreation and owns separate full-pose screen and yaw/floor VR origins. The camera worker uses a generation guard, a bounded latest-frame queue, and no SDK lifecycle operations in callbacks. + +Head polling is approximately every 4 ms with prediction disabled; this is not a claim of a 250 Hz sensor. Camera-rate callbacks provide a liveness check. Stale or unstable poses retain the last rendered transform and produce an invalid SteamVR pose. While a positional session is active, DroidDeck covers the resulting grey view with a themed recovery screen on the phone and glasses, including one readable copy per eye in SBS. It distinguishes tracking loss, USB disconnection, required recentering, and stabilization after recentering. Tracking-loss instructions ask the user to look around slowly in a well-lit room with visible detail, keep the cameras clear, and open the setup diagnostics to restart tracking if recovery stalls. Phone controls remain accessible, and the screen closes automatically when tracking is valid. Freshness is checked even if pose callbacks stop. Repeated USB timeouts require connection recovery rather than a synthetic valid pose. Large pose discontinuities latch a setup requirement. Provider shutdown invalidates queued work before closing the vendor provider and Java USB connection. + +The 176-byte `droiddeck-spatialpose` snapshot uses protocol version 4 and sequence-counter publication. The driver validates file length, version, finite normalized poses, and monotonic age. Head and both hands use one snapshot and one VR origin. Hand pose flags independently identify valid palm tracking (bit 0), pinch (bit 1), and grip (bit 2); head flags use only bit 0. The formerly reserved 32-bit word at byte offset 36 is now `input_epochs`, containing independent 8-bit loss counters for left trigger, left grip, right trigger, and right grip, from least to most significant byte. The layout size and pose offsets are unchanged, but versions 1 through 3 are rejected; app and driver must be rebuilt together. + +Snapshot flags select positional tracking (bit 0), bare-hand controllers (bit 1), or Luma Joy-Con +controllers (bit 2). The latter two selections are mutually exclusive; either enables stereo inference. +The Joy-Con mode consumes only wrist landmark 0 and the original capture timestamp; rotation and inputs +come from the paired Joy-Con. `luma_joycon.h` selects fresh stereo positions or a 6DoF-head-anchored arm +model independently per hand, rejects observations over 1.5 m from the head, and blends source switches +with a 180 ms time constant. It never integrates accelerometer position or uses the phone-camera +correction in this mode. Stale head poses invalidate output and release inputs. Selected mode flags +survive disconnect so a lost Luma cannot silently switch to a fixed-origin controller. Origin/connection +changes reset both positional blending and controller yaw alignment. This is hand-assisted tracking, +not a detector for the controller shell; see [Joy-Con setup and limits](../cardboard-vr.md#joy-con-controllers). + +Each counter advances when its gesture becomes ineligible, including invalid finger data, hand/head loss, and observation expiry. It survives later valid snapshots, allowing the driver to notice a short loss even if it never read the intervening invalid snapshot. Counters wrap independently within their bytes. Connection/origin changes reset driver input state, and a gap beyond 200 ms from its last accepted observation also releases inputs. Every hand retains its original camera observation timestamp: experimental hand poses and inputs expire after 200 ms, while head poses expire after 100 ms. A changed loss counter disarms only its affected gesture. Duplicate or older observations cannot rearm an input or replay a press; a new, valid released observation is required after loss before another press. Missing finger data never counts as a release gesture. Head updates cannot extend a hand observation's lifetime. Diagnostics expose the hand limit as `handMaxAgeMs`. + +The driver submits trigger scalar, trigger click, and grip updates before submitting the controller pose, including when the pose is becoming invalid. Disconnect and deactivation also clear inputs first. Changes in input state, loss counters, or API error codes produce concise driver log records with raw gestures, output values, armed state, pose/input validity, observation age, connection, and origin. Successful input API calls confirm submission to SteamVR; they do not prove that the dashboard received its mouse-up event. The installed dashboard grab handler retains a hand attachment until mouse-up and has no tracking-loss cleanup in that JavaScript component. Recovery of the reported stuck dashboard drag therefore still requires hardware validation; the implementation does not manufacture another press or a valid pose to force release. + +Controller display smoothing has no stationary anchors or dead zones. Small intentional motion remains visible; smoothing and prediction do not change the measured pose used for gesture validation. + +The displayed controller converges toward each measured palm pose on every driver update with one 15 ms correction time constant and normalized, hemisphere-corrected quaternions. There is no additional per-observation smoothing stage. After three consecutive observations with consistent motion, translation advances from the result's receipt time for at most 80 ms and 2 cm; capture timestamps still determine velocity and freshness. Receipt-relative prediction can continue between delayed inference results instead of consuming its entire horizon before a result arrives. Prediction is disabled above 1.5 m/s or 6 m/s², on a missed/invalid observation, head loss, or changed origin/connection. A missed observation freezes the last displayed transform through duplicate old samples until a newer observation arrives or the original 350 ms visual-hold expiry is reached. Fast motion reaches the 2 cm bound sooner, and correction adds a small settling delay. Stabilization and prediction do not alter gesture values or observation timestamps and cannot replace measured latency validation. + +The screen shader puts translation in `extra.yzw`, rotates the eye offset, and rejects intersections behind the eye. SBS and flat branches ignore translation. The push-constant allocation stays unchanged. A screen reference can include pitch and roll, preserving placement while reclining. + +## Stereo reconstruction and limitations + +Skipped camera pairs do not require clock warmup again when the source/host offset remains consistent. A source gap above 200 ms checks that offset against the existing 20 ms bound instead of unconditionally resetting synchronization. Nonmonotonic or invalid timestamps and inconsistent long gaps require 16 fresh observations; normal short-gap jitter retains the existing rolling-minimum and p90 policy. This preserves synchronization through a processing stall without publishing expired hand observations. + +Palm orientation uses an explicit hand side. The lateral axis reverses for the right hand so mirrored palms have the same normal and finger-direction convention; the existing left-hand mapping is retained. This corrects the mathematical right-hand inversion, while physical controller aiming still needs confirmation. + +The stock two-hand video graph can repeat whole-image palm detection when fewer than two hands were tracked previously. With both hands tracked it can skip that search; see the [MediaPipe graph](https://github.com/google-ai-edge/mediapipe/blob/master/mediapipe/tasks/cc/vision/hand_landmarker/hand_landmarker_graph.cc#L259). CPU scheduling maintains two persistent detector banks, each containing one detector per camera: one bank permits one hand, and the other permits two. After three observations agree on exactly one confident hand in both cameras, the one-hand bank handles intervening frames, and a two-hand search becomes due after 240 ms of camera time, running on the next processed frame. Both hands, a miss, handedness disagreement, nonmonotonic time, or a gap above 400 ms return selection to the two-hand bank. Second-hand discovery therefore remains enabled but can wait for the next scheduled search and processing. Banks retain their video tracking state between selections; they are not rebuilt per frame. GPU retains the ordinary two-hand bank. Diagnostics expose the active bank as `inferenceHandLimit`, alongside raw and filtered hand counts and per-camera timing. These choices reduce unnecessary searches by design; their benefit and extra model-memory cost require device measurement. + +The primary `left0/right0` images are copied only for diagnostics, calibration, or enabled hands. At most one pair is pending while the worker processes another. Automatic exposure is retained because the cameras also serve native VIO. SDK 2.4.0 documents the tracking-camera rate as 25 Hz and provides no stereo frame-rate setter. Polling more frequently does not create additional camera frames. The camera-rate readout accounts for skipped source-frame sequence numbers instead of treating processed-pair throughput as sensor rate. The selected video-mode Hand Landmarker pair receives matching timestamps. CPU inference runs the cameras concurrently with separate image buffers; each bank's right detector is created, used, and closed on one dedicated worker. Both calls must finish before pixels or detectors can be reused, including after failure or shutdown interruption. GPU inference remains serial on its owning thread. The pipeline detects landmarks in the original grayscale images replicated into RGB channels, without image normalization or fisheye remapping, corrects landmark coordinates for stereo reconstruction, matches unambiguous same-handed candidates, rejects excessive reprojection or implausible depth, and derives the palm pose from triangulated landmarks. Gesture recognition uses agreement between the two image-space finger estimates. MediaPipe world landmarks are not treated as headset-relative positions. + +The public header does not document the coordinate basis of the camera-rate pose callback. Its pose values are therefore not used as canonical head transforms. A bounded history of polled OpenGL poses supplies the capture-time transform. Source-to-host clock offsets must first stabilize over at least 16 observations; callback timestamp agreement and a nearby canonical head sample are required. Hand inference starts without waiting for the matching VIO callback, then checks for that exact camera timestamp before reconstruction can publish a valid pose. Missing confirmation, changed connections/tracking frames, invalid head tracking, and hand observations older than 200 ms still discard the result. Calibration and preview-only acquisition retain their bounded pose wait. Receipt-based offset estimation cannot establish absolute camera latency. External motion-to-visible-controller measurement is still required. Increasing expiry can reduce disappearing controllers at the cost of displaying older poses; it does not resolve GPU device loss or establish the latency/performance gates. + +Stereo validation retains the original 3-pixel reprojection, positive-depth, and 15–150 cm depth checks per landmark. Bare-hand controller position and orientation require a valid triangulated wrist and all four palm knuckles (0, 5, 9, 13, 17). Joy-Con mode reconstructs wrist landmark 0 only and takes orientation and inputs from the paired controller. Live pinch and grip no longer require trustworthy fingertip depth: each image estimates palm-normalized pinch and middle/ring/little finger curl, then both views must agree. Grip combines fingertip reach and finger-chain bending, with separate press/release thresholds and three curled fingers to press versus two to retain a press. Invalid, degenerate, or conflicting image evidence releases only its affected gesture and requires an observed release before rearming. A valid 3D palm is never sufficient by itself to invent a grab or click. Calibration and distance validation still require every board point to pass. Conservative stereo association rejects ambiguous hands rather than inventing depth. Crossed hands, edge-on palms, and occlusion may reduce availability. The 2D gesture consensus and aiming still require physical testing through grabs, pulls, and releases; they do not establish an accuracy or latency pass. No skeleton output, desktop gestures, fast-action guarantee, or hands-only locomotion is provided. + +Diagnostics include automatic or manual half/full input rates and a Lite-model comparison. Choices reset with the tracking session; the default is full-model parallel CPU with scheduled discovery and an adaptive rate starting at 500 permille. The Lite bundle uses Google's Lite palm detector and Lite landmark model with matching Tasks metadata. Both bundles are checksum-pinned in Gradle and at runtime; `tools/build_hand_lite.py` reproduces the candidate from pinned inputs. Saved-pair CPU replay compares full-model two-hand inference, scheduled full, scheduled lite, then full-model two-hand inference again, all with concurrent cameras. Rows identify `parallel` and `scheduled`; samples identify `inferenceHandLimit`. Its timings exclude model construction and cannot establish live detection coverage, external latency, second-hand discovery delay, or game performance. + +## Combined release gates + +| Area | Required evidence | +|---|---| +| Translation | Measured right/up/back movement and approximately 1:1 meter scale; lean and crouch; no double application | +| Origins | Crouched recenter preserves floor; picture switching preserves independent screen and VR references | +| Screens | Anchoring while moving sideways, toward and away; stable output after crossing the screen plane | +| Hands | At least 95% valid slow unobstructed observations at 30–80 cm; position error at most 5 cm; stationary jitter at most 2 cm | +| Latency | External physical-motion-to-visible-controller p95 below 100 ms | +| Recovery | Immediate release on detected loss; observation expiry extended to 200 ms by user request; clear-hand reacquisition within 500 ms | +| Performance | At most 10% regression in p95 game frame time over 20 minutes, with baseline frame rate maintained | +| Gameplay | Dashboard selection and Angry Birds VR aim, grip, pull, release | +| Robustness | Crossed hands, partial occlusion, head motion, lighting, USB reconnect, thermal load | + +Record results in `luma-spatial-evidence.md`. A build or head-tracking pass alone does not satisfy this combined gate. diff --git a/docs/development/rayneo-xr.md b/docs/development/rayneo-xr.md index e197b8a8de..0de7f77196 100644 --- a/docs/development/rayneo-xr.md +++ b/docs/development/rayneo-xr.md @@ -149,6 +149,11 @@ DroidDeck SteamVR session. Library launch diagnostics are in logs remain in `vrstartup.log` and Steam's logs directory. It does not intercept arbitrary external `steam://` URLs or change VR game launch arguments. +Only VR-only games (`vr_only`) wait for SteamVR and start it. Games where VR is +optional, such as No Man's Sky, launch normally unless SteamVR is already +running; before this they started (and if needed downloaded) SteamVR on every +Play, so they opened in VR without the user asking for it. + Validation: seven bridge/dispatch tests passed under Node/Python, five Android SteamVR launch tests passed, shell syntax passed and the debug APK built with runtime input verification. The broader Linux compatibility suite cannot run diff --git a/docs/development/viture-sdk.md b/docs/development/viture-sdk.md index c6f009d5e3..38aa17de63 100644 --- a/docs/development/viture-sdk.md +++ b/docs/development/viture-sdk.md @@ -1,5 +1,7 @@ # VITURE Android SDK integration +For the cross-brand feature matrix and user setup, see [smart-glasses support](../smart-glasses-support.md). + The optional adapter is built against the user-supplied VITURE XR Glasses SDK 2.4.0. Set `droiddeck.vitureSdk=C:/path/to/VITURE_XR_Glasses_SDK_for_Android` in the ignored `local.properties`, or pass `-PvitureSdkDir=/path/to/sdk`. @@ -26,9 +28,10 @@ Device firmware can reject individual modes; Android's physical display size must confirm SBS before the app considers the switch successful. All three feed the existing `Glasses.PoseSink`, head recentering, compositor and -SteamVR pipeline. Ultra explicitly selects 3DoF before SDK initialization because -the current pipeline consumes orientation. Positional 6DoF and camera passthrough -are outside this integration. The SDK's optional statistics reporter is not enabled. +SteamVR pipeline. Ultra selects 3DoF or the opt-in positional 6DoF mode before SDK +initialization. Its positional poses and stereo cameras feed the +[Luma spatial pipeline](luma-spatial-tracking.md); camera passthrough is not implemented. +The SDK's optional statistics reporter is not enabled. The SDK owns USB interface selection and I/O. `UsbDeviceConnection` remains open until stop/shutdown/destroy finish. A generation token rejects callbacks from an @@ -40,19 +43,64 @@ mode can fall back to the native table, with rollback on failure. `Game on glasses` uses Android's existing Presentation output. USB control alone does not create a video display: the phone, cable and adapter must expose a usable -external display. Discovery checks both display name and product metadata, with +external display. Enabling 3D also enables and saves `Game on glasses` before +requesting the stereo mode, so the picture uses the glasses' presentation instead +of the mirrored phone output. Returning to 2D keeps the game on the glasses. +Discovery checks both display name and product metadata, with a single unnamed-display fallback when recognized glasses USB is present. Screen width and distance apply to **Virtual screen** rendering. In **Automatic**, -ordinary 2D games stay flat, ordinary games with a confirmed SBS display use a -virtual screen, and a running SteamVR session uses the direct stereo view. +ordinary 2D games stay flat. On an SBS display, the complete flat frame is fitted +into each eye without cropping or head tracking. A running SteamVR session uses +the direct stereo view. Games or videos that already contain separate eye images +use the explicit **Side-by-side game** picture setting. Switching SBS on does not +activate a virtual screen or head tracking for ordinary games. The direct view uses SteamVR field of view instead of virtual-screen dimensions while SteamVR is running. A plain side-by-side game fills each eye and does not use the SteamVR field-of-view or recenter controls. -The settings UI and session renderer share this mode selection through -`GlassesRendering`; home-screen changes configure sessions rather than resizing -Android's mirrored launcher. Regular refresh rate applies to 2D output; SBS uses -the model's separate 3D refresh rate. + +All supported glasses with an available head-tracking connection have a separate +**3DoF virtual screen** toggle, including VITURE, RayNeo and XREAL 1S. Availability +comes from the connected transport's IMU capability rather than a model whitelist. +The app renders this screen without enabling a built-in 3DoF mode or changing +brightness. Enabling it selects Virtual screen, head tracking and Game on glasses, +and saves those preferences without changing the glasses' 2D/SBS mode. It works +with flat games in either display mode. Disabling it returns the picture to Automatic; switching +SBS on or off preserves the 3DoF selection. Virtual screens center on the current +viewing direction when tracking starts or the user recenters, including the +up/down angle. Direct SteamVR views retain their gravity-aligned recentering. + +The settings UI, menu presentation, and session renderer share this mode selection +through `GlassesRendering`. Setup → Smart glasses configures DroidDeck menus, +non-Steam launchers, desktop sessions, and games. Tracked menus use the app's own +glasses presentation while phone controls remain available; see +[tracked menus](glasses-menu-tracking.md). Regular refresh rate applies to 2D +output; SBS uses the model's separate 3D refresh rate. +Both the home menu and session drawer use **Display**, **VR**, **Tracking**, and +**Device** tabs. Display groups connection and output controls, 2D/3D resolution +and active refresh rate, then picture and virtual-screen geometry. VR contains +SteamVR controls, automatic 3D, VR resolution, and field of view. Tracking groups +head orientation, position and floor, and hands with camera setup. Device contains +brightness, volume, and sunblock. Unsupported hardware tabs are hidden. Recenter +is the first action on every session tab while head tracking is enabled for a +3DoF/6DoF virtual screen or SteamVR. + +Display saves **2D resolution** and **3D resolution**; VR saves **VR resolution**. Values are per eye: 1920 x 1080 or, on tall VITURE +models, 1920 x 1200. Automatic keeps the existing model default; VR defaults to +following the active 2D/3D preference. Home settings expose all three profiles, +while a running session shows the active profile next to its refresh control. +Switching resolution retains the refresh preference and does not change brightness, +color processing, or the session's game-rendering resolution. Android selects an +advertised mode with matching dimensions and the closest available refresh rate, +without crossing the 2D/SBS layout. VITURE's USB command selects the matching +resolution family first. A saved resolution unsupported by another attached model +falls back to its automatic behavior. Resolution controls wait for a pending SBS +transition to finish before accepting another change. + +Both lists offer 30 Hz only when Android advertises a matching native display mode at the current +resolution and **Game on glasses** is enabled. Android's presentation selects that mode without a +vendor command. A saved 30 Hz choice falls back to 60 Hz if the display or eye layout lacks it; +mirrored output never substitutes a 30 fps rendering limit. Software picture controls remain available while a display is connected even if USB control is lost; hardware controls and head tracking still require USB. Presentation refresh preferences are revalidated on display changes even when diff --git a/docs/development/x86-64-steam-client.md b/docs/development/x86-64-steam-client.md index aebfe51342..25e25a700c 100644 --- a/docs/development/x86-64-steam-client.md +++ b/docs/development/x86-64-steam-client.md @@ -186,27 +186,43 @@ alone would then read as an installed client. restarted from the top forever (found with `perf_event_open` IP sampling, since proot holds ptrace). Such a range is now skipped whole and a second exhausted scan returns `-ENOMEM`, as the kernel does (`fex-2610-r3`). -- **`build-fex.yml`.** The build job runs third-party images and toolchains with a read-only token, - and inputs reach the shell as environment variables. A separate publish job (contents: write) runs - only on a dispatch with a tag, host thunks on and no extra `cxxflags` (diagnostic builds such as - `-DDEBUG_STRACE` stay artifacts). `droiddeck-steam-x64` pins each tag's sha256 and the archive is not - reproducible, so a tag is never rebuilt over. The release is never the repo's Latest nor a - pre-release: it is a component fetched by tag, not something users install. +- **Building and publishing.** Droid-Deck/DroidDeck-Components' `build-fex.yml` builds `tools/fex` from + this repository at a chosen ref (default `main`) with host thunks, in the same Arch Linux ARM container + with a read-only token, then a separate job replaces `fex.tzst` on Components' single `fex` release, + checks the digest GitHub stored, and records the build's version, sha256 and size in its `fex.json` + (in that order: a device that reads the old `fex.json` meanwhile gets a mismatching archive and keeps + its FEX). This repository's `build-fex.yml` only builds `tools/fex` when it changes (and on dispatch, + for diagnostic builds such as `-DDEBUG_STRACE`); nothing is published from it. - Releases so far: `fex-2609-r2` (no thunks), `fex-2609-r3` (thunks), `fex-2610-r1`, `fex-2610-r2`, `fex-2610-r3`, `fex-2610-r4` (in-root resolution when openat2 is missing, exact MAP_32BIT marking), `fex-2610-r5` (current: bundles libxxhash, which the Linux runtime does not ship; the build fails when a program in the package needs a library that is neither bundled nor listed in `tools/fex/runtime-libs.txt`). They were built and published in The412Banner/DroidDeck; up to r3 their tags point at that - repository's `main`, from r4 at the commit each was built from. + repository's `main`, from r4 at the commit each was built from. Later builds are versions on the single + `fex` release; `fex-2610-r5` stays published as the build `droiddeck-steam-x64` pins. - **Where the app gets it.** The app downloads FEX from Droid-Deck/DroidDeck-Components, where nothing is - uploaded by hand: a new tag is published by `build-fex.yml`, recorded in that repository's `fex.json` - (sha256 and size), and brought in by its `mirror-release.yml`, which refuses an archive that does not - match. `FEX_TAG` and `FEX_SHA256` in `droiddeck-steam-x64` then move to the new tag. The rootfs is + uploaded by hand. The app follows its `fex.json`: while the x86-64 client is selected it reads it from + Components' `main` (directly, at most every ten minutes) and keeps the last copy, and a session passes + that build to `droiddeck-steam-x64` (`BL_FEX_TAG`, `BL_FEX_SHA256`, `BL_FEX_URLS` with the download + source's mirrors). The script installs a build only after its archive matches the sha256 and every + program in it loads (`ld-linux --list`); the files it replaces are kept aside until the installed copy + loads too and put back otherwise, and the tag is written last. Otherwise it keeps the installed one while that still loads, + then falls back to `FEX_TAG`/`FEX_SHA256` built in, which stay the first-start default when no copy + of `fex.json` has been read. Publishing a FEX build therefore takes a Components run only; a + replaced archive cannot be pointed back to, so undoing a build means building an earlier ref. The rootfs is FEX-Emu's own image, unmodified: `fex-rootfs.json` there names its rootfs.fex-emu.gg link, sha256 and size, and `mirror-upstream.yml` fetches it into the catalog's release only when both match. A newer image is a new catalog release; `ROOTFS_URL` and `ROOTFS_SHA256` then move to it, and a device that already unpacked one keeps it. +- **What a session log shows.** `FEX ready (, )` names the build and where it came from + (`catalog`, `built-in`, or `kept` when a newer one did not install, with the reason a line above); + `x86-64 rootfs:` names the image; `x86-64 client:` the client's ubuntu12 and steamrt64 builds at start + (it may update itself after). The rootfs download reports every tenth of its size as a step. When the + web helper's GPU process keeps exiting until Chromium gives up on the GPU (the menus then never appear), + one line says so with the exit codes, followed by x86 `glxinfo -B` and `vulkaninfo --summary` through + FEX's thunks. + ## DroidDeck direct for Linux games and runtimes - Steam runs native Linux games in the Steam Linux Runtime container (pressure-vessel), which needs diff --git a/docs/progress-log.md b/docs/progress-log.md index 65a26cbde3..81ec5bc3a3 100644 --- a/docs/progress-log.md +++ b/docs/progress-log.md @@ -139,6 +139,27 @@ the timeline, then lessons and backlog. Companion to the README (what the app *d FEX uses). With the device's libxxhash hidden, r4 failed with the reported error and r5 loaded. Mirrored in DroidDeck-Components (#5); the app moves to fex-2610-r5 and an installed r4 is replaced at the next x86-64 start. +- Merged as 7d21ba22. +- **FEX from the catalog**: FEX builds may need to follow user reports faster than app builds, so the + app now reads Components' `fex.json` (directly, kept between starts) and passes it to the session; a + build is installed only once its sha256 matches and its programs load, the installed one stays while it + loads, and the build pinned in the script remains the first-start default. **Session logs** for the + x86-64 client now name the FEX build and its source, the rootfs and the client's builds, report the + rootfs download in tenths instead of a progress bar (one report's log ended in hundreds of bar lines), + and, when the web helper's GPU process keeps exiting (a report from an Adreno 840: the menus never + appeared), say so in one line with x86 `glxinfo`/`vulkaninfo` through FEX. Settings shows the FEX + build installed. FEX is now built and published by DroidDeck-Components' `build-fex.yml` from this + repository's `tools/fex`, replacing the archive on its single `fex` release and recording the version + in `fex.json`; this repository's `build-fex.yml` only checks the build. Tests: `test_fex_select.py`, + `FexCatalogTest`. + Components' first build there published `2610-r6` (run 39104443888). Device (Pocket FIT, r4 + installed): the app read `fex.json`, and the next x86-64 start logged `downloading FEX (fex-2610-r6)` + then `FEX ready (fex-2610-r6, catalog)` a second later, with the rootfs and client lines; the client + came up on it. +- Review of #1053: an install keeps the files it replaces aside until the installed copy loads and puts + them back otherwise (a failed copy could leave a partly replaced FEX marked as the new one; + `test_fex_install.py`), and the catalog is read on its own thread, not before the library scan, and + not in Offline Mode. ## 2026-10-15 - `feat/x86-64-steam-client`: SD card library, ARM parity, org main, Counter-Strike 2 diff --git a/docs/releases/0.5.0.md b/docs/releases/0.5.0.md new file mode 100644 index 0000000000..096ffef3ba --- /dev/null +++ b/docs/releases/0.5.0.md @@ -0,0 +1,162 @@ +# DroidDeck 0.5.0 + +

Join the DroidDeck Discord

+ +### Features + +- Added **SteamVR on Meta Quest 3 and 3S** from the standard APK. Quest headsets are detected automatically and get their own driver defaults. Immersive SteamVR runs through a native OpenXR activity with headset tracking, Touch controllers and haptics, and SteamVR's dashboard and Steam library work in VR. (@xXJSONDeruloXx, @Jagger15, [#642](https://github.com/Droid-Deck/DroidDeck/pull/642), [#910](https://github.com/Droid-Deck/DroidDeck/pull/910), [#733](https://github.com/Droid-Deck/DroidDeck/pull/733), [#853](https://github.com/Droid-Deck/DroidDeck/pull/853), [#905](https://github.com/Droid-Deck/DroidDeck/pull/905)) + + On a Quest 3: DroidDeck in passthrough, Steam Big Picture in the headset, the SteamVR dashboard with a Touch controller, then playing Thumper in VR + +
+ Flat games on Quest with hand tracking + + Plants vs. Zombies on a DroidDeck panel in Quest passthrough, played with hand tracking + +
+- Added experimental **Meta Quest 2** support. (@Jagger15, [#676](https://github.com/Droid-Deck/DroidDeck/pull/676)) +- Added **XR glasses support for VITURE, RayNeo and XREAL**. Games play straight on the glasses at their own refresh rate while the phone becomes the controller, and the glasses' refresh rate, 3D mode, brightness, volume and sunblock can be changed from the app or the session menu. **Play SteamVR** appears beside Play Steam when supported glasses are connected, with head tracking from the glasses. Joy-Cons work as SteamVR hands, and the phone's camera can track bare hands with Quest-style pinch gestures. Supports VITURE Pro XR, RayNeo Air and GT glasses, and XREAL 1S (experimental). Glasses with head tracking can also show a **head-tracked virtual screen** everywhere in DroidDeck, in its menus, desktop sessions and games, without starting SteamVR, set up from the new **Setup → Smart glasses** page. (@maxjivi05, @informalTechCode, [#732](https://github.com/Droid-Deck/DroidDeck/pull/732), [#907](https://github.com/Droid-Deck/DroidDeck/pull/907), [#1035](https://github.com/Droid-Deck/DroidDeck/pull/1035)) + + Play SteamVR beside Play Steam with VITURE Pro XR glasses connected + Angry Birds VR from Play SteamVR, rendered in stereo with head pose from the glasses and the slingshot pulled with the gamepad + +
+ On the glasses, and gamepad hands in SteamVR + + Recorded from the glasses' own 1920×1080 display: Angry Birds VR with one eye's view, slingshot pulled with the gamepad + Gamepad hands pointing at Angry Birds VR's level select + +
+- Added **Cardboard VR mode** with Valve's ARM64 SteamVR, splitting the screen into two lens-corrected eyes with head tracking. Windows VR games such as Thumper and The Thrill of the Fight run through Proton. SteamVR and Cardboard share one **VR** tab in the session menu. (@xXJSONDeruloXx, [#704](https://github.com/Droid-Deck/DroidDeck/pull/704), [#959](https://github.com/Droid-Deck/DroidDeck/pull/959)) + + Thumper in Cardboard VR mode, split into two lens-corrected eyes + The Thrill of the Fight's weigh-in scene in Cardboard VR mode + The session menu's VR tab with SteamVR and Cardboard sections +- Added **Epic Games Launcher for Linux**, Epic's own client, running under FEX and signed in automatically with your linked Epic account. Every Epic game now starts through Steam and the launcher, so games get the same sign-in and online services as on a PC, along with Steam Input and the performance overlay. The launcher can be driven with a gamepad or touch. Games installed from inside the launcher appear in the Games tab automatically, and your Steam games can be started from the launcher's library. (@maxjivi05, [#928](https://github.com/Droid-Deck/DroidDeck/pull/928)) + + Opening the Epic Games Launcher from the Epic tab, already signed in, and browsing its library + The Epic Games Launcher in the Games tab next to Epic games, with Launch and Uninstall + +
+ Gamepad navigation and launching through Steam + + Moving the selection ring across the launcher's library with the D-pad + Launching Alone With You from the Games tab: Steam starts the launcher in the background, which hands the game back to Steam + The Epic Games Launcher's library running on DroidDeck + +
+- Added an optional **x86-64 Steam client**: Valve's own Linux client, running under FEX beside the default ARM64 one. Choose it under **Steam client** in Steam settings; it applies at the next session. It has its own game library and shares your sign-in. Games with a Linux version, such as Team Fortress 2 and Half-Life, run their Linux builds on it, and Windows games use DroidDeck-Proton as before. New FEX builds reach it without an app update. (@The412Banner, [#152](https://github.com/Droid-Deck/DroidDeck/pull/152), [#1050](https://github.com/Droid-Deck/DroidDeck/pull/1050), [#1053](https://github.com/Droid-Deck/DroidDeck/pull/1053)) +- **Linux games run under FEX out of the box.** Proton Experimental ARM64, FEX and the Steam Linux Runtimes now download on the first Steam start instead of waiting as pending downloads. x86 Linux games start, keep running and take the controller under FEX, including Unity games, which used to crash or ignore the gamepad. Games that also have a Windows version stay on Proton by default, because the Windows build often runs better. To run a game's Linux build instead, choose **Linux x86 (FEX)** in its compatibility settings. (@maxjivi05, [#1045](https://github.com/Droid-Deck/DroidDeck/pull/1045)) +- Store game pages now show **HowLongToBeat times, Metacritic scores**, developer, publisher and release date for GOG and Epic games, along with an **achievements** card with filters for unlocked, locked and hidden achievements. (@phobos665, @xXJSONDeruloXx, [#641](https://github.com/Droid-Deck/DroidDeck/pull/641), [#712](https://github.com/Droid-Deck/DroidDeck/pull/712), [#775](https://github.com/Droid-Deck/DroidDeck/pull/775)) + + Backpack Hero's Epic page with its Metacritic score of 76, HowLongToBeat times and achievements card +- Added opt-in **GOG achievements** syncing through Comet, with unlock notifications while you play. (@xXJSONDeruloXx, [#651](https://github.com/Droid-Deck/DroidDeck/pull/651)) +- Added **sorting and a list view** for the store Library and Installed tabs: sort by recently played, recently installed, title, size or release date, and switch between cards and a compact list. (@kingokksa, [#798](https://github.com/Droid-Deck/DroidDeck/pull/798)) + + Sorting the Epic library by size and by title, then switching from the card grid to the list view +- Added a **Storage** page to Setup that shows where DroidDeck's storage goes and frees what is safe to remove: unused Steam runtimes, leftovers from uninstalled games, old logs, shader caches, unused components and Flatpak runtimes. Starting Steam with less than 10 GB free offers to free up space. (@xXJSONDeruloXx, [#913](https://github.com/Droid-Deck/DroidDeck/pull/913)) + + Storage page overview with the internal storage bar and its categories + Storage Clean up checklist with sizes and the safe items selected +- Added **artwork changing for Steam games and GOG, Epic and Amazon games**, matching added games, with a SteamGridDB search in the art chooser. **Adjust logo** sets where a game's logo sits on its background and how big it is. Chosen art and logo positions are applied in Steam too. (@FX192, [#876](https://github.com/Droid-Deck/DroidDeck/pull/876), [#939](https://github.com/Droid-Deck/DroidDeck/pull/939), [#948](https://github.com/Droid-Deck/DroidDeck/pull/948), [#976](https://github.com/Droid-Deck/DroidDeck/pull/976), [#1004](https://github.com/Droid-Deck/DroidDeck/pull/1004)) + + The Artwork editor for Moonlighter, a Steam game, with its cover, background, logo and icon +- Redesigned the **GPU drivers** page with three modes: **Auto**, **Matched pair**, or **Mix and match** display and runtime drivers. It also shows which drivers are in use now. Auto checks for new drivers when the app opens, and if a new pair never starts a session, it rolls back to the last pair that worked. (@xXJSONDeruloXx, [#858](https://github.com/Droid-Deck/DroidDeck/pull/858), [#972](https://github.com/Droid-Deck/DroidDeck/pull/972)) + + GPU drivers page with Auto, Matched pair and Mix and match, and the drivers in use +- Added **Boot movie** settings: the DroidDeck movie at 30 or 60 fps, with or without sound, or import your own video, which is converted on the device. (@xXJSONDeruloXx, [#969](https://github.com/Droid-Deck/DroidDeck/pull/969)) + + Boot movie settings in the Steam settings sheet: movie, sound and Import +- Added a per-game **Start without Steam** switch for games that close right away because of Proton's Steam setup. (@The412Banner, [#659](https://github.com/Droid-Deck/DroidDeck/pull/659)) +- Added **Low-latency controller** and **Low-latency touch** toggles to the session menu, which apply immediately while Steam is running. (@xXJSONDeruloXx, [#808](https://github.com/Droid-Deck/DroidDeck/pull/808)) + + The session menu's Latency group with Low-latency controller and Low-latency touch +- A **three-finger tap** opens and closes Steam's on-screen keyboard in game. (@xXJSONDeruloXx, [#782](https://github.com/Droid-Deck/DroidDeck/pull/782)) +- Added **Picture position** (Top, Bottom or Center) for Steam sessions, so fixed-aspect games can sit away from on-screen controls on tall screens. (@asdf17128, [#871](https://github.com/Droid-Deck/DroidDeck/pull/871)) + + Picture position in the Steam settings Display tab +- FEX, DXVK and VKD3D-Proton versions can be **downloaded from the session menu**. (@xXJSONDeruloXx, [#679](https://github.com/Droid-Deck/DroidDeck/pull/679)) +- Added opt-in **zRAM compression** for the Steam client while a game runs, freeing about 0.5–0.8 GB of memory in testing. (@maxjivi05, [#442](https://github.com/Droid-Deck/DroidDeck/pull/442)) +- Added **23 more languages**, for 32 in total besides English, selectable in the app or in Android's per-app language settings. Steam follows the chosen language. (@maxjivi05, [#669](https://github.com/Droid-Deck/DroidDeck/pull/669)) +- Downloads now **resume where they stopped** and fall back to mirrors, with a download source setting that picks the fastest source automatically. This helps especially in mainland China. (@kingokksa, [#623](https://github.com/Droid-Deck/DroidDeck/pull/623)) +- Added **Reset all settings** in Setup > Diagnostics. It keeps your games, sign-ins and downloads. (@0x1Nawaf, [#696](https://github.com/Droid-Deck/DroidDeck/pull/696)) +- Store installs can go to **internal storage, any SD card or your second library**. (@maxjivi05, [#928](https://github.com/Droid-Deck/DroidDeck/pull/928)) +- Controllers with two back paddles (such as the 8BitDo Mobile Controller) map them to the Deck's **L4 and R4**. (@Vynex, [#797](https://github.com/Droid-Deck/DroidDeck/pull/797)) +- The second screen's Deck controls now include the **Gamepad** tab. On foldables, the unfolded controls hide while a controller is connected. (@ovurrsl, @Gustash, [#895](https://github.com/Droid-Deck/DroidDeck/pull/895), [#829](https://github.com/Droid-Deck/DroidDeck/pull/829)) +- Added experimental **Android Auto** support. DroidDeck is only available while the car is parked, and needs Android Auto's developer mode with unknown sources enabled. (@zekena2, [#952](https://github.com/Droid-Deck/DroidDeck/pull/952)) + +### Improvements + +- **Rewrote the Epic and Amazon store modules**, with byte-exact download verification and proper controller focus on store game pages. Existing sign-ins and installs carry over. (@The412Banner, [#802](https://github.com/Droid-Deck/DroidDeck/pull/802), [#804](https://github.com/Droid-Deck/DroidDeck/pull/804)) +- **Epic installs need far less free space.** Files are assembled as they download instead of caching the whole game first, so a 71 GB game no longer needs about 142 GB free. Store installs also check for space first and recover better when they run short. (@jmarti326, [#710](https://github.com/Droid-Deck/DroidDeck/pull/710)) +- **Fewer background processes.** An idle Steam session went from about 41 processes to about 30, keeping it further under Android's child-process limit, and Steam's web helper uses about 250 MB less memory. (@xXJSONDeruloXx, [#566](https://github.com/Droid-Deck/DroidDeck/pull/566), [#575](https://github.com/Droid-Deck/DroidDeck/pull/575)) +- **Smoother frame pacing.** The session respects Android's peak refresh rate setting, frames are timed to the display's vsync, Steam's frame limiter paces each game by time, and frame generation follows the game's real frame rate. On a 60 Hz Thor, distinct frames on screen rose from about 49.5 to 59.4 a second. (@xXJSONDeruloXx, [#715](https://github.com/Droid-Deck/DroidDeck/pull/715), [#717](https://github.com/Droid-Deck/DroidDeck/pull/717), [#731](https://github.com/Droid-Deck/DroidDeck/pull/731), [#753](https://github.com/Droid-Deck/DroidDeck/pull/753), [#927](https://github.com/Droid-Deck/DroidDeck/pull/927)) +- The game's busiest threads are boosted onto the **prime cores on the Odin 3**, and Snapdragon 8 Gen 2 devices get default core assignments for games and Steam. (@kmnkv1, @xXJSONDeruloXx, [#682](https://github.com/Droid-Deck/DroidDeck/pull/682), [#654](https://github.com/Droid-Deck/DroidDeck/pull/654)) +- Games on **SD-card libraries launch faster**, about 46% faster in testing. (@xXJSONDeruloXx, [#757](https://github.com/Droid-Deck/DroidDeck/pull/757)) +- The Steam home wall now fills from **your own Steam library**, and the store sign-in screens show each store's featured art. (@xXJSONDeruloXx, [#835](https://github.com/Droid-Deck/DroidDeck/pull/835), [#878](https://github.com/Droid-Deck/DroidDeck/pull/878)) +- **Older and less common devices:** sessions start on kernels that drop fork events (such as the Xiaomi Pad 5), Flatpak installs work on older kernels, the Linux runtime installs on 16 KB page-size devices, and USB drives that only appear as raw storage can be granted All files access. (@xXPOLYGONXx, @xXJSONDeruloXx, @ovurrsl, @Imgau, [#457](https://github.com/Droid-Deck/DroidDeck/pull/457), [#752](https://github.com/Droid-Deck/DroidDeck/pull/752), [#900](https://github.com/Droid-Deck/DroidDeck/pull/900), [#760](https://github.com/Droid-Deck/DroidDeck/pull/760)) +- Controller-driven cursors now show in nested Wayland sessions. (@xXJSONDeruloXx, [#759](https://github.com/Droid-Deck/DroidDeck/pull/759)) +- An interrupted Linux runtime download resumes instead of starting again. (@ovurrsl, [#847](https://github.com/Droid-Deck/DroidDeck/pull/847)) +- Native Linux and FEX compatibility choices are kept instead of being reset to Proton. (@xXJSONDeruloXx, [#749](https://github.com/Droid-Deck/DroidDeck/pull/749)) +- DroidDeck-Proton releases now come from the [Droid-Deck/DroidDeck-Proton](https://github.com/Droid-Deck/DroidDeck-Proton) repo. (@The412Banner, [#875](https://github.com/Droid-Deck/DroidDeck/pull/875)) +- Folding or unfolding no longer restarts the front end, file manager or store sign-in. (@ovurrsl, [#832](https://github.com/Droid-Deck/DroidDeck/pull/832), [#886](https://github.com/Droid-Deck/DroidDeck/pull/886)) +- Session reports include the memory page size, why the app's last processes ended, the panel's refresh modes and the device's thermal state. Logs are synced to storage every 2 seconds, so a hard reset keeps them, and only the 3 newest session log folders are kept. (@ovurrsl, @kmnkv1, @xXJSONDeruloXx, [#897](https://github.com/Droid-Deck/DroidDeck/pull/897), [#513](https://github.com/Droid-Deck/DroidDeck/pull/513), [#852](https://github.com/Droid-Deck/DroidDeck/pull/852), [#990](https://github.com/Droid-Deck/DroidDeck/pull/990)) +- The store sign-in page can no longer read local files. (@ovurrsl, [#890](https://github.com/Droid-Deck/DroidDeck/pull/890)) +- Expanded and refreshed translations, including Chinese, Japanese, Turkish, German, French, Spanish, Italian, Portuguese, Russian, Korean and Hungarian. Every language now has every string, including the new Storage, GPU drivers and artwork pages, and Latin American Spanish is complete. (@Dantalian-dev, @ovurrsl, @kingokksa, [#539](https://github.com/Droid-Deck/DroidDeck/pull/539), [#826](https://github.com/Droid-Deck/DroidDeck/pull/826), [#849](https://github.com/Droid-Deck/DroidDeck/pull/849), [#850](https://github.com/Droid-Deck/DroidDeck/pull/850), [#884](https://github.com/Droid-Deck/DroidDeck/pull/884), [#1013](https://github.com/Droid-Deck/DroidDeck/pull/1013)) + +### Fixed + +- Fixed **Android UI flickering** during games on Adreno 740 devices such as the AYN Thor and Odin 2 Portal. (@xXJSONDeruloXx, [#963](https://github.com/Droid-Deck/DroidDeck/pull/963)) +- Fixed **game rumble stopping after one second** under Proton. (@TideGear, [#938](https://github.com/Droid-Deck/DroidDeck/pull/938)) +- Fixed **Shut Down and Restart** in Steam's power menu. Shut Down now ends the session, and Restart restarts the client. (@muazkadan, [#629](https://github.com/Droid-Deck/DroidDeck/pull/629)) +- Fixed the **Quick Access button** doing nothing when the pad is set to Xbox 360, DualShock 4 or DualSense. (@muazkadan, [#631](https://github.com/Droid-Deck/DroidDeck/pull/631)) +- Fixed **store games becoming Steam installs** when you also own them on Steam. (@xXJSONDeruloXx, [#816](https://github.com/Droid-Deck/DroidDeck/pull/816)) +- Fixed **added games sometimes never starting** on a cold launch with large Steam libraries. (@xXJSONDeruloXx, @ovurrsl, [#758](https://github.com/Droid-Deck/DroidDeck/pull/758), [#914](https://github.com/Droid-Deck/DroidDeck/pull/914), [#973](https://github.com/Droid-Deck/DroidDeck/pull/973)) +- Fixed games that never started after a long pause, and "Steam is paused" staying up after the first Resume tap. (@maxjivi05, [#928](https://github.com/Droid-Deck/DroidDeck/pull/928)) +- Fixed the session ending the third time Steam restarted, for example after changing language. (@KirkPatrickJunsay, [#754](https://github.com/Droid-Deck/DroidDeck/pull/754)) +- Fixed Steam touch controls ignoring the layout chosen in Steam, including community layouts. (@xXJSONDeruloXx, [#840](https://github.com/Droid-Deck/DroidDeck/pull/840)) +- Fixed **Batman: Arkham City** crashing at startup and getting stuck on "Running install script". (@TjebbeKerstens, [#792](https://github.com/Droid-Deck/DroidDeck/pull/792), [#793](https://github.com/Droid-Deck/DroidDeck/pull/793)) +- Fixed **.NET Desktop and .NET Core runtimes** failing to install from Windows components, which blocked MelonLoader mods and Baldur's Gate 3. (@The412Banner, [#740](https://github.com/Droid-Deck/DroidDeck/pull/740)) +- Fixed the microphone in DirectAudio games. (@xXJSONDeruloXx, [#747](https://github.com/Droid-Deck/DroidDeck/pull/747)) +- Fixed FEX games failing with "Couldn't connect to FEXServer socket". (@angelrenefm, [#841](https://github.com/Droid-Deck/DroidDeck/pull/841)) +- Fixed wired **PowerA and PDP** Xbox controllers' right stick and triggers. (@Raidennrl, [#692](https://github.com/Droid-Deck/DroidDeck/pull/692)) +- Fixed touchpad taps not registering in some games, and the touchpad not moving a game's own cursor when it locks the pointer. (@KirkPatrickJunsay, @Gustash, [#644](https://github.com/Droid-Deck/DroidDeck/pull/644), [#772](https://github.com/Droid-Deck/DroidDeck/pull/772)) +- Fixed native touch taps snapping the cursor to the top-left corner in some games. (@asdf17128, [#803](https://github.com/Droid-Deck/DroidDeck/pull/803)) +- Fixed the Android keyboard needing two taps to open after it was dismissed. (@KirkPatrickJunsay, [#665](https://github.com/Droid-Deck/DroidDeck/pull/665)) +- Fixed Shift staying held after typing capitals on a physical keyboard in the desktop. (@The412Banner, [#766](https://github.com/Droid-Deck/DroidDeck/pull/766)) +- Fixed an unfolded Follow screen session no longer turning to portrait. (@Gustash, [#626](https://github.com/Droid-Deck/DroidDeck/pull/626)) +- Fixed battery estimates showing thousands of hours on phones that report current in mA. (@muazkadan, [#820](https://github.com/Droid-Deck/DroidDeck/pull/820)) +- Fixed blurry home-screen shortcuts for Steam games. (@KirkPatrickJunsay, [#825](https://github.com/Droid-Deck/DroidDeck/pull/825)) +- Fixed SteamGridDB art staying "no match" after a failed lookup. (@FX192, [#876](https://github.com/Droid-Deck/DroidDeck/pull/876)) +- Fixed Steam crashes returning to the launcher silently. They now show DroidDeck's error screen, and Steam no longer crashes on Quest when a SteamVR runtime is installed. (@xXJSONDeruloXx, [#905](https://github.com/Droid-Deck/DroidDeck/pull/905)) +- Fixed the in-session achievements page staying on "Reading…". (@xXJSONDeruloXx, [#961](https://github.com/Droid-Deck/DroidDeck/pull/961)) +- Fixed crashes from failed store background jobs and cloud save recovery, and a memory error in the directory cache. (@KirkPatrickJunsay, @ovurrsl, @wallentx, [#846](https://github.com/Droid-Deck/DroidDeck/pull/846), [#898](https://github.com/Droid-Deck/DroidDeck/pull/898), [#685](https://github.com/Droid-Deck/DroidDeck/pull/685)) +- Fixed expired Epic and Amazon sign-ins failing with a generic error instead of asking you to sign in again. (@The412Banner, [#804](https://github.com/Droid-Deck/DroidDeck/pull/804)) +- Fixed the child-process limit check on Android 12, and its switch name now matches Android's wording. (@ovurrsl, [#955](https://github.com/Droid-Deck/DroidDeck/pull/955), [#848](https://github.com/Droid-Deck/DroidDeck/pull/848)) +- Fixed the launcher offering its own display as a second screen. (@ovurrsl, [#889](https://github.com/Droid-Deck/DroidDeck/pull/889)) +- Fixed Windows component detection being confused by folder names above the game folder. (@xXJSONDeruloXx, [#859](https://github.com/Droid-Deck/DroidDeck/pull/859)) +- Fixed FEX dropdown scaling and Flathub search focus. (@xXJSONDeruloXx, [#681](https://github.com/Droid-Deck/DroidDeck/pull/681)) + +### New contributors + +- @xXPOLYGONXx made their first contribution in [#457](https://github.com/Droid-Deck/DroidDeck/pull/457). +- @phobos665 made their first contribution in [#637](https://github.com/Droid-Deck/DroidDeck/pull/637). +- @Jagger15 made their first contribution in [#642](https://github.com/Droid-Deck/DroidDeck/pull/642). +- @KirkPatrickJunsay made their first contribution in [#644](https://github.com/Droid-Deck/DroidDeck/pull/644). +- @wallentx made their first contribution in [#685](https://github.com/Droid-Deck/DroidDeck/pull/685). +- @Raidennrl made their first contribution in [#692](https://github.com/Droid-Deck/DroidDeck/pull/692). +- @0x1Nawaf made their first contribution in [#696](https://github.com/Droid-Deck/DroidDeck/pull/696). +- @Producdevity made their first contribution in [#748](https://github.com/Droid-Deck/DroidDeck/pull/748). +- @Imgau made their first contribution in [#760](https://github.com/Droid-Deck/DroidDeck/pull/760). +- @TjebbeKerstens made their first contribution in [#792](https://github.com/Droid-Deck/DroidDeck/pull/792). +- @Vynex made their first contribution in [#797](https://github.com/Droid-Deck/DroidDeck/pull/797). +- @kingokksa made their first contribution in [#798](https://github.com/Droid-Deck/DroidDeck/pull/798). +- @asdf17128 made their first contribution in [#803](https://github.com/Droid-Deck/DroidDeck/pull/803). +- @ovurrsl made their first contribution in [#831](https://github.com/Droid-Deck/DroidDeck/pull/831). +- @FX192 made their first contribution in [#876](https://github.com/Droid-Deck/DroidDeck/pull/876). +- @angelrenefm made their first contribution in [#894](https://github.com/Droid-Deck/DroidDeck/pull/894). +- @informalTechCode made their first contribution in [#907](https://github.com/Droid-Deck/DroidDeck/pull/907). +- @TideGear made their first contribution in [#938](https://github.com/Droid-Deck/DroidDeck/pull/938). +- @zekena2 made their first contribution in [#952](https://github.com/Droid-Deck/DroidDeck/pull/952). + +[Full changelog](https://github.com/Droid-Deck/DroidDeck/compare/0.4.0...0.5.0) diff --git a/docs/releases/media/0.5.0/boot-movie.jpg b/docs/releases/media/0.5.0/boot-movie.jpg new file mode 100644 index 0000000000..a54f2cffcf Binary files /dev/null and b/docs/releases/media/0.5.0/boot-movie.jpg differ diff --git a/docs/releases/media/0.5.0/cardboard-thrill-of-the-fight.jpg b/docs/releases/media/0.5.0/cardboard-thrill-of-the-fight.jpg new file mode 100644 index 0000000000..855492cde9 Binary files /dev/null and b/docs/releases/media/0.5.0/cardboard-thrill-of-the-fight.jpg differ diff --git a/docs/releases/media/0.5.0/cardboard-thumper.jpg b/docs/releases/media/0.5.0/cardboard-thumper.jpg new file mode 100644 index 0000000000..6743f4c0f2 Binary files /dev/null and b/docs/releases/media/0.5.0/cardboard-thumper.jpg differ diff --git a/docs/releases/media/0.5.0/epic-launch-through-steam.gif b/docs/releases/media/0.5.0/epic-launch-through-steam.gif new file mode 100644 index 0000000000..8d14404330 Binary files /dev/null and b/docs/releases/media/0.5.0/epic-launch-through-steam.gif differ diff --git a/docs/releases/media/0.5.0/epic-launcher-gamepad.gif b/docs/releases/media/0.5.0/epic-launcher-gamepad.gif new file mode 100644 index 0000000000..2cd399e312 Binary files /dev/null and b/docs/releases/media/0.5.0/epic-launcher-gamepad.gif differ diff --git a/docs/releases/media/0.5.0/epic-launcher-games-tab.jpg b/docs/releases/media/0.5.0/epic-launcher-games-tab.jpg new file mode 100644 index 0000000000..38cc032178 Binary files /dev/null and b/docs/releases/media/0.5.0/epic-launcher-games-tab.jpg differ diff --git a/docs/releases/media/0.5.0/epic-launcher-library.jpg b/docs/releases/media/0.5.0/epic-launcher-library.jpg new file mode 100644 index 0000000000..70ce1d5abb Binary files /dev/null and b/docs/releases/media/0.5.0/epic-launcher-library.jpg differ diff --git a/docs/releases/media/0.5.0/epic-launcher.gif b/docs/releases/media/0.5.0/epic-launcher.gif new file mode 100644 index 0000000000..32aebeb31f Binary files /dev/null and b/docs/releases/media/0.5.0/epic-launcher.gif differ diff --git a/docs/releases/media/0.5.0/game-page-hltb-metacritic.jpg b/docs/releases/media/0.5.0/game-page-hltb-metacritic.jpg new file mode 100644 index 0000000000..d6066abd0d Binary files /dev/null and b/docs/releases/media/0.5.0/game-page-hltb-metacritic.jpg differ diff --git a/docs/releases/media/0.5.0/glasses-2d.gif b/docs/releases/media/0.5.0/glasses-2d.gif new file mode 100644 index 0000000000..c9256cd48d Binary files /dev/null and b/docs/releases/media/0.5.0/glasses-2d.gif differ diff --git a/docs/releases/media/0.5.0/glasses-gamepad-hands.gif b/docs/releases/media/0.5.0/glasses-gamepad-hands.gif new file mode 100644 index 0000000000..a93b9bc718 Binary files /dev/null and b/docs/releases/media/0.5.0/glasses-gamepad-hands.gif differ diff --git a/docs/releases/media/0.5.0/glasses-steamvr.gif b/docs/releases/media/0.5.0/glasses-steamvr.gif new file mode 100644 index 0000000000..cafc002ade Binary files /dev/null and b/docs/releases/media/0.5.0/glasses-steamvr.gif differ diff --git a/docs/releases/media/0.5.0/gpu-drivers.jpg b/docs/releases/media/0.5.0/gpu-drivers.jpg new file mode 100644 index 0000000000..97383b13a6 Binary files /dev/null and b/docs/releases/media/0.5.0/gpu-drivers.jpg differ diff --git a/docs/releases/media/0.5.0/low-latency.jpg b/docs/releases/media/0.5.0/low-latency.jpg new file mode 100644 index 0000000000..53621fc054 Binary files /dev/null and b/docs/releases/media/0.5.0/low-latency.jpg differ diff --git a/docs/releases/media/0.5.0/picture-position.jpg b/docs/releases/media/0.5.0/picture-position.jpg new file mode 100644 index 0000000000..d13b133186 Binary files /dev/null and b/docs/releases/media/0.5.0/picture-position.jpg differ diff --git a/docs/releases/media/0.5.0/play-steamvr-glasses.jpg b/docs/releases/media/0.5.0/play-steamvr-glasses.jpg new file mode 100644 index 0000000000..2849e05041 Binary files /dev/null and b/docs/releases/media/0.5.0/play-steamvr-glasses.jpg differ diff --git a/docs/releases/media/0.5.0/quest-flat-hands.gif b/docs/releases/media/0.5.0/quest-flat-hands.gif new file mode 100644 index 0000000000..fb71d41753 Binary files /dev/null and b/docs/releases/media/0.5.0/quest-flat-hands.gif differ diff --git a/docs/releases/media/0.5.0/quest-steamvr.gif b/docs/releases/media/0.5.0/quest-steamvr.gif new file mode 100644 index 0000000000..1c5758b136 Binary files /dev/null and b/docs/releases/media/0.5.0/quest-steamvr.gif differ diff --git a/docs/releases/media/0.5.0/sort-list-view.gif b/docs/releases/media/0.5.0/sort-list-view.gif new file mode 100644 index 0000000000..a2c780ebb5 Binary files /dev/null and b/docs/releases/media/0.5.0/sort-list-view.gif differ diff --git a/docs/releases/media/0.5.0/steam-artwork.jpg b/docs/releases/media/0.5.0/steam-artwork.jpg new file mode 100644 index 0000000000..df8470dcc1 Binary files /dev/null and b/docs/releases/media/0.5.0/steam-artwork.jpg differ diff --git a/docs/releases/media/0.5.0/storage-cleanup.jpg b/docs/releases/media/0.5.0/storage-cleanup.jpg new file mode 100644 index 0000000000..f1b562251c Binary files /dev/null and b/docs/releases/media/0.5.0/storage-cleanup.jpg differ diff --git a/docs/releases/media/0.5.0/storage-overview.jpg b/docs/releases/media/0.5.0/storage-overview.jpg new file mode 100644 index 0000000000..2a8f362f1a Binary files /dev/null and b/docs/releases/media/0.5.0/storage-overview.jpg differ diff --git a/docs/releases/media/0.5.0/vr-drawer-tab.jpg b/docs/releases/media/0.5.0/vr-drawer-tab.jpg new file mode 100644 index 0000000000..8d6c78bbae Binary files /dev/null and b/docs/releases/media/0.5.0/vr-drawer-tab.jpg differ diff --git a/docs/smart-glasses-support.md b/docs/smart-glasses-support.md new file mode 100644 index 0000000000..dd70fbdaf3 --- /dev/null +++ b/docs/smart-glasses-support.md @@ -0,0 +1,81 @@ +# Smart-glasses support + +This describes the integrations implemented in DroidDeck as of 2026-10-17. A recognized product name alone does not establish that every firmware, phone, cable, or adapter supports every mode. Controls become available from the connected device's capabilities and the display modes Android actually exposes. + +**3DoF** tracks head rotation: turn, tilt, and roll around a virtual screen. **6DoF** also tracks head position, so leaning or moving changes the view. Both apply to DroidDeck menus, non-Steam launchers, desktop sessions, and games when the tracked virtual screen is enabled. Direct SteamVR rendering uses the corresponding headset pose instead of the virtual-screen layout. + +## Support levels + +- **Integrated:** a device transport and controls are implemented. Tracking requires a working connection and available orientation data. +- **SDK-dependent:** integrated support requires an APK built with the optional VITURE SDK. Recognizing the display does not mean that SDK is included. +- **Experimental:** implemented and opt-in, with the qualifications described below. This is not a general tracking-accuracy guarantee. +- **Display-only:** Android can provide a picture through a compatible display connection, but DroidDeck has no supported control/tracking connection for that device. + +## Device matrix + +| Brand / model family | Level and connection | App-wide 3DoF | App-wide 6DoF / SteamVR position | Luma stereo hand / Joy-Con position | +| --- | --- | --- | --- | --- | +| VITURE One / One Lite; Pro / Pro XR | Integrated legacy USB transport | Yes, when IMU connection is available | No | No | +| VITURE Luma / Luma Pro; Luma Cyber when identified by the SDK | Integrated Luma-family USB transport; Cyber identification uses the SDK market name | Yes, when IMU connection is available | No | No | +| VITURE Pro 2 / Pro 2 XR | SDK-dependent Gen2 transport and device identification | Yes | No | No | +| VITURE Beast | SDK-dependent Gen2 transport | Yes | No | No | +| **VITURE Luma Ultra** | SDK-dependent Carina transport | Yes | **Experimental, opt-in** | **Experimental, opt-in** | +| Recognized RayNeo / TCL Air-series devices | Integrated RayNeo USB transport | Yes, with orientation calibration controls | No | No | +| RayNeo GT-series devices matching the supported USB identity, including GT Max identification | Integrated GT USB/IMU path | Yes, with orientation calibration controls | No | No | +| **XREAL 1S** | **Experimental**; exact USB identity plus the device's USB-Ethernet control/IMU connection | Yes, when that connection is ready | No | No | +| Other XREAL models; unrecognized glasses; display adapters and docks | Display-only where Android exposes a usable display; automatic glasses routing also requires display recognition | No supported app tracking connection | No | No | + +RayNeo's Air-series recognition uses its known USB identity or a RayNeo/TCL Air name under the accepted vendor IDs; it is not a per-model certification list. The GT vendor path requires the specific supported product ID. XREAL support currently targets **1S only**: One, One Pro, Air-family devices, and recovery-mode products are not enabled by the 1S transport. VITURE Pro 2 is identified through SDK validation rather than a guessed product ID. A dock does not supply the connected glasses' sensors by itself. + +The final column refers specifically to Luma Ultra's stereo tracking cameras. DroidDeck's separate phone-camera and physical-controller features are independent of this matrix. + +## Display and device controls + +All display modes depend on the phone's video output, the cable/adapter, and Android's advertised modes. USB permission or a working sensor connection alone does not create a video display. + +| Integration | Display selection | Device controls exposed by DroidDeck | +| --- | --- | --- | +| VITURE One/Lite and Pro families | 1080p per eye; 2D and SBS | Brightness, volume, dimming toggle according to the family profile | +| VITURE Luma family | 1080p or 1200p per eye; 2D and SBS | Brightness, volume, dimming toggle | +| VITURE Luma Ultra | 1080p or 1200p per eye; 2D and SBS, including the family's 90 Hz SBS selection | Brightness, volume, dimming toggle | +| VITURE Beast | 1080p or 1200p per eye; SDK handles native/bypass display modes | Brightness, volume, dimming toggle | +| VITURE Pro 2 | 1080p per eye; 2D and SBS | Brightness and volume; no electrochromic-film control | +| RayNeo Air/GT | 2D/SBS switching; resolution and refresh follow available Android modes | Orientation calibration; no app brightness, volume, or dimming commands | +| XREAL 1S | Supported 1S display-mode commands, including native 1200p/60 Hz and SBS | Brightness and dimming toggle; no app volume command | + +DroidDeck saves separate **2D resolution**, **3D resolution**, and **VR resolution** preferences. Unsupported saved choices fall back to the connected model's automatic behavior. Native **30 Hz** is offered only when Android advertises a matching mode and glasses presentation output is enabled. Higher refresh selections are constrained by the active 2D/SBS layout and model; a firmware-rejected switch is not treated as successful until the physical display confirms it. + +In **Automatic** picture mode, ordinary flat content is duplicated in full into both eyes on an SBS display. **Virtual screen** adds a configurable screen plane and tracking. **Side-by-side game** is for content that already contains separate eye images. SteamVR uses its direct stereo view and field-of-view control. + +## Setup and app-wide behavior + +1. Connect the glasses through a compatible video/data connection. Accept USB access when requested. For XREAL 1S, Android must also expose the glasses' USB-Ethernet network; the app leaves Steam's Internet connection on its normal network. +2. Open **Setup → Smart glasses**. Enable glasses output and **3DoF virtual screen**. This selects the tracked screen and saves the setting without forcing SBS or changing brightness. +3. Adjust screen width and distance, then recenter while looking where the screen should sit. The same settings apply when navigating DroidDeck, opening a non-Steam launcher, or entering a game/desktop session. +4. On an SDK-enabled Luma Ultra, optionally enable positional tracking and set the floor from the current eye height. Use the tracking setup and recovery controls for calibration or recentering. SteamVR startup defers Luma positional initialization until two seconds after SteamVR reports running. + +The phone remains the touch/control surface. DroidDeck mirrors its own visible UI into a tracked glasses presentation; it does not capture Android's entire desktop or other apps. Android 29+ can include app dialogs/popups, while Android 26–28 captures the activity's decor only. System keyboards and permission prompts, secure windows, and separately composed `SurfaceView` content stay on their existing surfaces. Menu recentering does not change the VR floor origin. See [tracked-menu behavior](development/glasses-menu-tracking.md). + +## Luma Ultra tracking qualifications + +Positional tracking, bare-hand controllers, and camera-assisted Joy-Cons are separate options and default off. Bare hands and camera-assisted Joy-Cons are mutually exclusive. + +- **Head tracking:** the SDK supplies the positional pose. The app checks freshness and connection/origin generations and provides tracking-loss and recenter recovery. Screen and floor origins are separate. +- **Bare hands:** Full palm + Full landmarks is the default. Raw grayscale is replicated into RGB, MediaPipe applies model tensor normalization, and calibration corrects landmark coordinates before stereo triangulation. Full landmarks support palm orientation, pinch, and grab. The small saved-image comparison favored Full over Lite but does not establish universal hand-detection quality; see the [comparison results](development/hand-model-comparison-2026-10-16.md). +- **Controller visibility:** the last accepted visual pose can remain for up to 350 ms from capture time during a short detection gap. Invalid/stale gestures release independently. Normal hand mode has no stationary dead zone; shoulder-based **Steady hand aim** is a separate opt-in setting. +- **Joy-Cons:** camera position uses wrist landmark 0. Physical buttons and IMU orientation remain the input sources, with an arm estimate when a usable camera position is unavailable. Camera wrist position does not make a physical controller fully optically tracked in every pose. Screen and Joy-Con recenter actions are separate. +- **Calibration:** the included 640×480 Luma Ultra stereo profile is a model-specific starting point. A matching saved device profile takes precedence. The shared profile is labeled separately from an individually distance-verified calibration; optional board collection and distance validation refine a device profile. +- **RGB camera:** the third camera remains diagnostic-only. It is not used for controller depth, hand tracking, or camera passthrough. The failed hybrid stereo matcher and temporary USB transport experiments are not part of the live pipeline. + +## Build and troubleshooting references + +Luma Ultra, Beast, and Pro 2 control/tracking require the optional, externally supplied **VITURE Android SDK 2.4.0** in the APK build. Without it, DroidDeck retains its legacy VITURE and RayNeo transports and the separate XREAL integration; it cannot advertise SDK-dependent tracking. Vendor SDK headers and binaries are not stored in this repository. See [VITURE SDK setup](development/viture-sdk.md). + +If only a flat picture is available, check video output first, then the control connection. A disabled tracking toggle can mean missing SDK support, missing USB/network access, or a device without a supported IMU transport. SBS or a new resolution requires a confirmed physical display mode; selecting a preference cannot add a mode the phone/display does not expose. + +- [Luma spatial setup, calibration, and diagnostics](development/luma-spatial-tracking.md) +- [Tracked DroidDeck menu implementation](development/glasses-menu-tracking.md) +- [Agent diagnostics and capture commands](agent-control.md) +- [RayNeo attribution and protocol references](third-party/rayneo/README.md) + +The capability definitions are maintained in [VITURE models](../app/src/main/java/com/droiddeck/launcher/glasses/VitureProtocol.kt), [RayNeo models](../app/src/main/java/com/droiddeck/launcher/glasses/RayNeoModel.kt), [XREAL 1S](../app/src/main/java/com/droiddeck/launcher/glasses/XrealModel.kt), and [connection capability routing](../app/src/main/java/com/droiddeck/launcher/glasses/Glasses.kt). Update this matrix when those integrations change. diff --git a/docs/third-party/handtracking/README.md b/docs/third-party/handtracking/README.md index 653d1c4ce9..10107a197f 100644 --- a/docs/third-party/handtracking/README.md +++ b/docs/third-party/handtracking/README.md @@ -2,8 +2,8 @@ ## Included -[MediaPipe](https://github.com/google-ai-edge/mediapipe) Tasks Vision 0.10.21 -(`com.google.mediapipe:tasks-vision`, tag `v0.10.21` at cad7f3ab99ebf175947e40c5252c642612aae927; +[MediaPipe](https://github.com/google-ai-edge/mediapipe) Tasks Vision 1.0.0 +(`com.google.mediapipe:tasks-vision`, shared with the Luma stereo tracking pipeline; copyright Google LLC and the MediaPipe authors, Apache License 2.0, `LICENSE_MEDIAPIPE` here) finds the player's body in each camera frame. It comes from Maven Central with its dependencies (Guava, Flogger, protobuf-javalite and Google's `datatransport`), all Apache-2.0. @@ -24,6 +24,16 @@ bundle, a palm detector and a hand landmark model, unchanged from licenses it under the Apache License 2.0; it gives 21 landmarks per hand in the picture and in metres, based on the GHUM hand model, and is meant for prominently shown hands. +The Luma stereo pipeline defaults to the Full bundle at +`app/src/main/assets/models/hand_landmarker.task`, with the same checksum as the Full bundle +above. The optional `app/src/main/assets/models/hand_landmarker_lite.task` is built from +the official `palm_detection_lite.tflite` and `hand_landmark_lite.tflite` assets at +`https://storage.googleapis.com/mediapipe-assets/`. It uses the matching tensor metadata and +associated labels from the Full task bundle. These models share the MediaPipe hand tracking +model card and Apache License 2.0. Source checksums and the generated bundle checksum are in +`app/src/main/assets/models/hand_landmarker_lite.provenance.json`; `tools/build_hand_lite.py` +reproduces the bundle with MediaPipe 0.10.21 metadata tooling. + [CameraX](https://developer.android.com/jetpack/androidx/releases/camera) 1.4.2 (`androidx.camera:camera-camera2`, `camera-lifecycle`; copyright The Android Open Source Project, Apache License 2.0) delivers the frames. diff --git a/docs/third-party/uvc/LICENSE_LIBUSB b/docs/third-party/uvc/LICENSE_LIBUSB new file mode 100644 index 0000000000..5ab7695ab8 --- /dev/null +++ b/docs/third-party/uvc/LICENSE_LIBUSB @@ -0,0 +1,504 @@ + GNU LESSER GENERAL PUBLIC LICENSE + Version 2.1, February 1999 + + Copyright (C) 1991, 1999 Free Software Foundation, Inc. + 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + +[This is the first released version of the Lesser GPL. It also counts + as the successor of the GNU Library Public License, version 2, hence + the version number 2.1.] + + Preamble + + The licenses for most software are designed to take away your +freedom to share and change it. By contrast, the GNU General Public +Licenses are intended to guarantee your freedom to share and change +free software--to make sure the software is free for all its users. + + This license, the Lesser General Public License, applies to some +specially designated software packages--typically libraries--of the +Free Software Foundation and other authors who decide to use it. You +can use it too, but we suggest you first think carefully about whether +this license or the ordinary General Public License is the better +strategy to use in any particular case, based on the explanations below. + + When we speak of free software, we are referring to freedom of use, +not price. Our General Public Licenses are designed to make sure that +you have the freedom to distribute copies of free software (and charge +for this service if you wish); that you receive source code or can get +it if you want it; that you can change the software and use pieces of +it in new free programs; and that you are informed that you can do +these things. + + To protect your rights, we need to make restrictions that forbid +distributors to deny you these rights or to ask you to surrender these +rights. These restrictions translate to certain responsibilities for +you if you distribute copies of the library or if you modify it. + + For example, if you distribute copies of the library, whether gratis +or for a fee, you must give the recipients all the rights that we gave +you. You must make sure that they, too, receive or can get the source +code. If you link other code with the library, you must provide +complete object files to the recipients, so that they can relink them +with the library after making changes to the library and recompiling +it. And you must show them these terms so they know their rights. + + We protect your rights with a two-step method: (1) we copyright the +library, and (2) we offer you this license, which gives you legal +permission to copy, distribute and/or modify the library. + + To protect each distributor, we want to make it very clear that +there is no warranty for the free library. Also, if the library is +modified by someone else and passed on, the recipients should know +that what they have is not the original version, so that the original +author's reputation will not be affected by problems that might be +introduced by others. + + Finally, software patents pose a constant threat to the existence of +any free program. We wish to make sure that a company cannot +effectively restrict the users of a free program by obtaining a +restrictive license from a patent holder. Therefore, we insist that +any patent license obtained for a version of the library must be +consistent with the full freedom of use specified in this license. + + Most GNU software, including some libraries, is covered by the +ordinary GNU General Public License. This license, the GNU Lesser +General Public License, applies to certain designated libraries, and +is quite different from the ordinary General Public License. We use +this license for certain libraries in order to permit linking those +libraries into non-free programs. + + When a program is linked with a library, whether statically or using +a shared library, the combination of the two is legally speaking a +combined work, a derivative of the original library. The ordinary +General Public License therefore permits such linking only if the +entire combination fits its criteria of freedom. The Lesser General +Public License permits more lax criteria for linking other code with +the library. + + We call this license the "Lesser" General Public License because it +does Less to protect the user's freedom than the ordinary General +Public License. It also provides other free software developers Less +of an advantage over competing non-free programs. These disadvantages +are the reason we use the ordinary General Public License for many +libraries. However, the Lesser license provides advantages in certain +special circumstances. + + For example, on rare occasions, there may be a special need to +encourage the widest possible use of a certain library, so that it becomes +a de-facto standard. To achieve this, non-free programs must be +allowed to use the library. A more frequent case is that a free +library does the same job as widely used non-free libraries. In this +case, there is little to gain by limiting the free library to free +software only, so we use the Lesser General Public License. + + In other cases, permission to use a particular library in non-free +programs enables a greater number of people to use a large body of +free software. For example, permission to use the GNU C Library in +non-free programs enables many more people to use the whole GNU +operating system, as well as its variant, the GNU/Linux operating +system. + + Although the Lesser General Public License is Less protective of the +users' freedom, it does ensure that the user of a program that is +linked with the Library has the freedom and the wherewithal to run +that program using a modified version of the Library. + + The precise terms and conditions for copying, distribution and +modification follow. Pay close attention to the difference between a +"work based on the library" and a "work that uses the library". The +former contains code derived from the library, whereas the latter must +be combined with the library in order to run. + + GNU LESSER GENERAL PUBLIC LICENSE + TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION + + 0. This License Agreement applies to any software library or other +program which contains a notice placed by the copyright holder or +other authorized party saying it may be distributed under the terms of +this Lesser General Public License (also called "this License"). +Each licensee is addressed as "you". + + A "library" means a collection of software functions and/or data +prepared so as to be conveniently linked with application programs +(which use some of those functions and data) to form executables. + + The "Library", below, refers to any such software library or work +which has been distributed under these terms. A "work based on the +Library" means either the Library or any derivative work under +copyright law: that is to say, a work containing the Library or a +portion of it, either verbatim or with modifications and/or translated +straightforwardly into another language. (Hereinafter, translation is +included without limitation in the term "modification".) + + "Source code" for a work means the preferred form of the work for +making modifications to it. For a library, complete source code means +all the source code for all modules it contains, plus any associated +interface definition files, plus the scripts used to control compilation +and installation of the library. + + Activities other than copying, distribution and modification are not +covered by this License; they are outside its scope. The act of +running a program using the Library is not restricted, and output from +such a program is covered only if its contents constitute a work based +on the Library (independent of the use of the Library in a tool for +writing it). Whether that is true depends on what the Library does +and what the program that uses the Library does. + + 1. You may copy and distribute verbatim copies of the Library's +complete source code as you receive it, in any medium, provided that +you conspicuously and appropriately publish on each copy an +appropriate copyright notice and disclaimer of warranty; keep intact +all the notices that refer to this License and to the absence of any +warranty; and distribute a copy of this License along with the +Library. + + You may charge a fee for the physical act of transferring a copy, +and you may at your option offer warranty protection in exchange for a +fee. + + 2. You may modify your copy or copies of the Library or any portion +of it, thus forming a work based on the Library, and copy and +distribute such modifications or work under the terms of Section 1 +above, provided that you also meet all of these conditions: + + a) The modified work must itself be a software library. + + b) You must cause the files modified to carry prominent notices + stating that you changed the files and the date of any change. + + c) You must cause the whole of the work to be licensed at no + charge to all third parties under the terms of this License. + + d) If a facility in the modified Library refers to a function or a + table of data to be supplied by an application program that uses + the facility, other than as an argument passed when the facility + is invoked, then you must make a good faith effort to ensure that, + in the event an application does not supply such function or + table, the facility still operates, and performs whatever part of + its purpose remains meaningful. + + (For example, a function in a library to compute square roots has + a purpose that is entirely well-defined independent of the + application. Therefore, Subsection 2d requires that any + application-supplied function or table used by this function must + be optional: if the application does not supply it, the square + root function must still compute square roots.) + +These requirements apply to the modified work as a whole. If +identifiable sections of that work are not derived from the Library, +and can be reasonably considered independent and separate works in +themselves, then this License, and its terms, do not apply to those +sections when you distribute them as separate works. But when you +distribute the same sections as part of a whole which is a work based +on the Library, the distribution of the whole must be on the terms of +this License, whose permissions for other licensees extend to the +entire whole, and thus to each and every part regardless of who wrote +it. + +Thus, it is not the intent of this section to claim rights or contest +your rights to work written entirely by you; rather, the intent is to +exercise the right to control the distribution of derivative or +collective works based on the Library. + +In addition, mere aggregation of another work not based on the Library +with the Library (or with a work based on the Library) on a volume of +a storage or distribution medium does not bring the other work under +the scope of this License. + + 3. You may opt to apply the terms of the ordinary GNU General Public +License instead of this License to a given copy of the Library. To do +this, you must alter all the notices that refer to this License, so +that they refer to the ordinary GNU General Public License, version 2, +instead of to this License. (If a newer version than version 2 of the +ordinary GNU General Public License has appeared, then you can specify +that version instead if you wish.) Do not make any other change in +these notices. + + Once this change is made in a given copy, it is irreversible for +that copy, so the ordinary GNU General Public License applies to all +subsequent copies and derivative works made from that copy. + + This option is useful when you wish to copy part of the code of +the Library into a program that is not a library. + + 4. You may copy and distribute the Library (or a portion or +derivative of it, under Section 2) in object code or executable form +under the terms of Sections 1 and 2 above provided that you accompany +it with the complete corresponding machine-readable source code, which +must be distributed under the terms of Sections 1 and 2 above on a +medium customarily used for software interchange. + + If distribution of object code is made by offering access to copy +from a designated place, then offering equivalent access to copy the +source code from the same place satisfies the requirement to +distribute the source code, even though third parties are not +compelled to copy the source along with the object code. + + 5. A program that contains no derivative of any portion of the +Library, but is designed to work with the Library by being compiled or +linked with it, is called a "work that uses the Library". Such a +work, in isolation, is not a derivative work of the Library, and +therefore falls outside the scope of this License. + + However, linking a "work that uses the Library" with the Library +creates an executable that is a derivative of the Library (because it +contains portions of the Library), rather than a "work that uses the +library". The executable is therefore covered by this License. +Section 6 states terms for distribution of such executables. + + When a "work that uses the Library" uses material from a header file +that is part of the Library, the object code for the work may be a +derivative work of the Library even though the source code is not. +Whether this is true is especially significant if the work can be +linked without the Library, or if the work is itself a library. The +threshold for this to be true is not precisely defined by law. + + If such an object file uses only numerical parameters, data +structure layouts and accessors, and small macros and small inline +functions (ten lines or less in length), then the use of the object +file is unrestricted, regardless of whether it is legally a derivative +work. (Executables containing this object code plus portions of the +Library will still fall under Section 6.) + + Otherwise, if the work is a derivative of the Library, you may +distribute the object code for the work under the terms of Section 6. +Any executables containing that work also fall under Section 6, +whether or not they are linked directly with the Library itself. + + 6. As an exception to the Sections above, you may also combine or +link a "work that uses the Library" with the Library to produce a +work containing portions of the Library, and distribute that work +under terms of your choice, provided that the terms permit +modification of the work for the customer's own use and reverse +engineering for debugging such modifications. + + You must give prominent notice with each copy of the work that the +Library is used in it and that the Library and its use are covered by +this License. You must supply a copy of this License. If the work +during execution displays copyright notices, you must include the +copyright notice for the Library among them, as well as a reference +directing the user to the copy of this License. Also, you must do one +of these things: + + a) Accompany the work with the complete corresponding + machine-readable source code for the Library including whatever + changes were used in the work (which must be distributed under + Sections 1 and 2 above); and, if the work is an executable linked + with the Library, with the complete machine-readable "work that + uses the Library", as object code and/or source code, so that the + user can modify the Library and then relink to produce a modified + executable containing the modified Library. (It is understood + that the user who changes the contents of definitions files in the + Library will not necessarily be able to recompile the application + to use the modified definitions.) + + b) Use a suitable shared library mechanism for linking with the + Library. A suitable mechanism is one that (1) uses at run time a + copy of the library already present on the user's computer system, + rather than copying library functions into the executable, and (2) + will operate properly with a modified version of the library, if + the user installs one, as long as the modified version is + interface-compatible with the version that the work was made with. + + c) Accompany the work with a written offer, valid for at + least three years, to give the same user the materials + specified in Subsection 6a, above, for a charge no more + than the cost of performing this distribution. + + d) If distribution of the work is made by offering access to copy + from a designated place, offer equivalent access to copy the above + specified materials from the same place. + + e) Verify that the user has already received a copy of these + materials or that you have already sent this user a copy. + + For an executable, the required form of the "work that uses the +Library" must include any data and utility programs needed for +reproducing the executable from it. However, as a special exception, +the materials to be distributed need not include anything that is +normally distributed (in either source or binary form) with the major +components (compiler, kernel, and so on) of the operating system on +which the executable runs, unless that component itself accompanies +the executable. + + It may happen that this requirement contradicts the license +restrictions of other proprietary libraries that do not normally +accompany the operating system. Such a contradiction means you cannot +use both them and the Library together in an executable that you +distribute. + + 7. You may place library facilities that are a work based on the +Library side-by-side in a single library together with other library +facilities not covered by this License, and distribute such a combined +library, provided that the separate distribution of the work based on +the Library and of the other library facilities is otherwise +permitted, and provided that you do these two things: + + a) Accompany the combined library with a copy of the same work + based on the Library, uncombined with any other library + facilities. This must be distributed under the terms of the + Sections above. + + b) Give prominent notice with the combined library of the fact + that part of it is a work based on the Library, and explaining + where to find the accompanying uncombined form of the same work. + + 8. You may not copy, modify, sublicense, link with, or distribute +the Library except as expressly provided under this License. Any +attempt otherwise to copy, modify, sublicense, link with, or +distribute the Library is void, and will automatically terminate your +rights under this License. However, parties who have received copies, +or rights, from you under this License will not have their licenses +terminated so long as such parties remain in full compliance. + + 9. You are not required to accept this License, since you have not +signed it. However, nothing else grants you permission to modify or +distribute the Library or its derivative works. These actions are +prohibited by law if you do not accept this License. Therefore, by +modifying or distributing the Library (or any work based on the +Library), you indicate your acceptance of this License to do so, and +all its terms and conditions for copying, distributing or modifying +the Library or works based on it. + + 10. Each time you redistribute the Library (or any work based on the +Library), the recipient automatically receives a license from the +original licensor to copy, distribute, link with or modify the Library +subject to these terms and conditions. You may not impose any further +restrictions on the recipients' exercise of the rights granted herein. +You are not responsible for enforcing compliance by third parties with +this License. + + 11. If, as a consequence of a court judgment or allegation of patent +infringement or for any other reason (not limited to patent issues), +conditions are imposed on you (whether by court order, agreement or +otherwise) that contradict the conditions of this License, they do not +excuse you from the conditions of this License. If you cannot +distribute so as to satisfy simultaneously your obligations under this +License and any other pertinent obligations, then as a consequence you +may not distribute the Library at all. For example, if a patent +license would not permit royalty-free redistribution of the Library by +all those who receive copies directly or indirectly through you, then +the only way you could satisfy both it and this License would be to +refrain entirely from distribution of the Library. + +If any portion of this section is held invalid or unenforceable under any +particular circumstance, the balance of the section is intended to apply, +and the section as a whole is intended to apply in other circumstances. + +It is not the purpose of this section to induce you to infringe any +patents or other property right claims or to contest validity of any +such claims; this section has the sole purpose of protecting the +integrity of the free software distribution system which is +implemented by public license practices. Many people have made +generous contributions to the wide range of software distributed +through that system in reliance on consistent application of that +system; it is up to the author/donor to decide if he or she is willing +to distribute software through any other system and a licensee cannot +impose that choice. + +This section is intended to make thoroughly clear what is believed to +be a consequence of the rest of this License. + + 12. If the distribution and/or use of the Library is restricted in +certain countries either by patents or by copyrighted interfaces, the +original copyright holder who places the Library under this License may add +an explicit geographical distribution limitation excluding those countries, +so that distribution is permitted only in or among countries not thus +excluded. In such case, this License incorporates the limitation as if +written in the body of this License. + + 13. The Free Software Foundation may publish revised and/or new +versions of the Lesser General Public License from time to time. +Such new versions will be similar in spirit to the present version, +but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Library +specifies a version number of this License which applies to it and +"any later version", you have the option of following the terms and +conditions either of that version or of any later version published by +the Free Software Foundation. If the Library does not specify a +license version number, you may choose any version ever published by +the Free Software Foundation. + + 14. If you wish to incorporate parts of the Library into other free +programs whose distribution conditions are incompatible with these, +write to the author to ask for permission. For software which is +copyrighted by the Free Software Foundation, write to the Free +Software Foundation; we sometimes make exceptions for this. Our +decision will be guided by the two goals of preserving the free status +of all derivatives of our free software and of promoting the sharing +and reuse of software generally. + + NO WARRANTY + + 15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO +WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR +OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY +KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE +IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR +PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE +LIBRARY IS WITH YOU. SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME +THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + + 16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN +WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY +AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU +FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR +CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING +RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A +FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF +SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH +DAMAGES. + + END OF TERMS AND CONDITIONS + + How to Apply These Terms to Your New Libraries + + If you develop a new library, and you want it to be of the greatest +possible use to the public, we recommend making it free software that +everyone can redistribute and change. You can do so by permitting +redistribution under these terms (or, alternatively, under the terms of the +ordinary General Public License). + + To apply these terms, attach the following notices to the library. It is +safest to attach them to the start of each source file to most effectively +convey the exclusion of warranty; and each file should have at least the +"copyright" line and a pointer to where the full notice is found. + + + Copyright (C) + + This library is free software; you can redistribute it and/or + modify it under the terms of the GNU Lesser General Public + License as published by the Free Software Foundation; either + version 2.1 of the License, or (at your option) any later version. + + This library is distributed in the hope that it will be useful, + but WITHOUT ANY WARRANTY; without even the implied warranty of + MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU + Lesser General Public License for more details. + + You should have received a copy of the GNU Lesser General Public + License along with this library; if not, write to the Free Software + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA + +Also add information on how to contact you by electronic and paper mail. + +You should also get your employer (if you work as a programmer) or your +school, if any, to sign a "copyright disclaimer" for the library, if +necessary. Here is a sample; alter the names: + + Yoyodyne, Inc., hereby disclaims all copyright interest in the + library `Frob' (a library for tweaking knobs) written by James Random Hacker. + + , 1 April 1990 + Ty Coon, President of Vice + +That's all there is to it! + + diff --git a/docs/third-party/uvc/LICENSE_LIBUVC b/docs/third-party/uvc/LICENSE_LIBUVC new file mode 100644 index 0000000000..4acc5ddeaf --- /dev/null +++ b/docs/third-party/uvc/LICENSE_LIBUVC @@ -0,0 +1,31 @@ +Software License Agreement (BSD License) + +Copyright (C) 2010-2015 Ken Tossell +All rights reserved. + +Redistribution and use in source and binary forms, with or without +modification, are permitted provided that the following conditions +are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the author nor other contributors may be + used to endorse or promote products derived from this software + without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS +"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT +LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS +FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE +COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, +INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, +BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER +CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT +LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN +ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE +POSSIBILITY OF SUCH DAMAGE. diff --git a/docs/third-party/uvc/README.md b/docs/third-party/uvc/README.md new file mode 100644 index 0000000000..66838c7ed4 --- /dev/null +++ b/docs/third-party/uvc/README.md @@ -0,0 +1,71 @@ +# RGB USB camera transport + +The optional RGB diagnostic backend uses [libusb 1.0.30](https://github.com/libusb/libusb/releases/tag/v1.0.30) +(LGPL 2.1 or later) and [libuvc 0.0.8](https://github.com/libuvc/libuvc/releases/tag/v0.0.8) +(BSD 3-Clause). Full license texts are in `LICENSE_LIBUSB` and `LICENSE_LIBUVC` here. + +`tools/build_rgb_uvc.py` obtains the official sources with these SHA-256 pins: + +| Source | SHA-256 | +| --- | --- | +| [libusb-1.0.30.tar.bz2](https://github.com/libusb/libusb/releases/download/v1.0.30/libusb-1.0.30.tar.bz2) | `fea36f34f9156400209595e300840767ab1a385ede1dc7ee893015aea9c6dbaf` | +| [libuvc v0.0.8 ZIP](https://github.com/libuvc/libuvc/archive/refs/tags/v0.0.8.zip) | `67922938ad81eb82b8ce14576f15a68ac75e30af738728a1f3070b6bbc938bce` | + +## Build and replace + +Use Python 3.12 or newer, Android NDK 27.3.13750724, CMake 3.22.1, and Ninja. +From the repository root on Windows: + +```powershell +python tools/build_rgb_uvc.py --ndk "$env:LOCALAPPDATA/Android/Sdk/ndk/27.3.13750724" --cmake "$env:LOCALAPPDATA/Android/Sdk/cmake/3.22.1/bin/cmake.exe" +``` + +The default output is `build/rgb-uvc/dist`: `arm64-v8a/libusb.so`, `arm64-v8a/libuvc.a`, +public headers in `include`, and license texts in `licenses`. The script records archive, +patch, recipe, and binary hashes plus complete build commands in `provenance.json`. +Use `--cache` to reuse downloaded archives and `--output` for an independent build. +Each run refreshes the extracted vendor sources from the pinned archives before patching. + +Set `droiddeck.uvcDir=C:/path/to/build/rgb-uvc/dist` in the untracked `local.properties`, or +pass `-PuvcDir=C:/path/to/build/rgb-uvc/dist` to Gradle. The optional backend and shared libusb +are packaged through CMake; license texts are staged into APK assets under `licenses/uvc`. +Without this input, the RGB SDK diagnostic remains available and direct UVC reports unavailable. + +libusb is a separate shared library with SONAME `libusb.so`; the application must package +it beside its JNI backend and keep it dynamically linked. libuvc is static PIC with hidden +symbols. A backend links `libuvc.a`, `libusb.so`, and Android `log`, and includes `libusb.h` +before `libuvc/libuvc.h`. Both native components target ARM64/API 26; shared libraries use +16 KiB ELF LOAD alignment. No JPEG conversion dependency is included: camera payloads +remain MJPEG and are decoded by the caller. + +To rebuild libusb with modifications, run the script once, edit its extracted sources under +the output's `src/libusb-1.0.30`, then use the recorded CMake configure/build commands directly +without rerunning the Python extraction step. Package the resulting `libusb.so` in a rebuilt +APK. Keep the corresponding sources, recipe, patches, and LGPL text with release source +distribution; do not rely solely on the upstream download links. The generated manifest +describes the pinned build; regenerate hashes when distributing modified binaries. + +## Local changes and validation + +libuvc's queue uses eight transfer buffers instead of the upstream Linux default of 100. +The per-transfer limit remains 32 isochronous packets. The patch in +`tools/uvc/libuvc-submit-failure.patch` preserves a USB submission error instead of returning +success with an incomplete or empty queue. Unsubmitted transfers are removed under the +callback mutex. The normal stop path then holds that mutex while checking and cancelling +remaining transfers, waits for completion callbacks to clear them, and joins the frame +callback thread before returning. This prevents cancellation of already-cleared slots. + +`uvc_submit_failure_test` replaces submission, cancellation, alternate-setting, and companion +descriptor USB calls with in-process fakes. It runs 60 starts covering failure before any +transfer, failure after three queued transfers, and all eight submitted successfully. Each +case checks the return code, cancellation count, stopped state, and cleared transfer slots. +The Android executable needs `libusb.so` on its loader path; it does not access USB hardware. +Building it verifies linking but does not execute the runtime tests. A separate device run +is required to confirm them: + +```sh +LD_LIBRARY_PATH=. ./uvc_submit_failure_test +``` + +The executable built under `build/rgb-uvc-reprotest` passed all 60 cases on the Fold7 on +2026-10-16. That run used simulated USB calls and does not establish camera-stream reliability. diff --git a/output/pdf/DroidDeck-Luma-Ultra-Calibration-Board.pdf b/output/pdf/DroidDeck-Luma-Ultra-Calibration-Board.pdf new file mode 100644 index 0000000000..c8d74025ad --- /dev/null +++ b/output/pdf/DroidDeck-Luma-Ultra-Calibration-Board.pdf @@ -0,0 +1,80 @@ +%PDF-1.3 +%“Œ‹ž ReportLab Generated PDF document (opensource) +1 0 obj +<< +/F1 2 0 R /F2 3 0 R +>> +endobj +2 0 obj +<< +/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font +>> +endobj +3 0 obj +<< +/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font +>> +endobj +4 0 obj +<< +/Contents 8 0 R /MediaBox [ 0 0 612 792 ] /Parent 7 0 R /Resources << +/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ] +>> /Rotate 0 /Trans << + +>> + /Type /Page +>> +endobj +5 0 obj +<< +/PageMode /UseNone /Pages 7 0 R /Type /Catalog /ViewerPreferences 9 0 R +>> +endobj +6 0 obj +<< +/Author (DroidDeck) /CreationDate (D:20261015162101-06'00') /Creator (anonymous) /Keywords () /ModDate (D:20261015162101-06'00') /Producer (ReportLab PDF Library - \(opensource\)) + /Subject (unspecified) /Title (DroidDeck Luma Ultra - 30 mm ChArUco Calibration Board) /Trapped /False +>> +endobj +7 0 obj +<< +/Count 1 /Kids [ 4 0 R ] /Type /Pages +>> +endobj +8 0 obj +<< +/Filter [ /ASCII85Decode /FlateDecode ] /Length 2054 +>> +stream +Gasb]9lJfF&;KZQ'lthN"qAIg;?;)Wl3&N(!X64;H4/fACiA_6\lotG$ifu3[Gm:*BIX9!>LMQ"iFk2(.15#.:Q5`^cc<3?%u*_Mj#;*ogN\=V>$rX24%TC!RN1p@/$+J(S%tGM>3(%3M59/UY,OqA-O,rU-t0LY^qJ#MAqXRobfU&4/06i2l"V).n:!:,^5"(/j[naEBamuHlGMSjn8>tZ'b[JDZCCF=C)#dKB,uYTZ*##'[(Cg!W.+9kg4?g-0.II=9P-`/2jTCca7>bpB`["kMA""8^\TW%dadQ(#E2f$Sie+XXf5d@bghFX4@#]272:d`51-JTg#qn\s[#g4S;khWsD.GG3b%%P%HkD%ZdrNm$A4##B0QWXO3C31-UN$9?`k>Za-7"VVl5hUR45V(%3%o*I,K3$?(QG$%l37@9&*u9OcD.Z[Kf]f$%V*_0A1E>G83r6OH=\VZbVqBeJ_9G*[.2*>mt-[*Fr;?T4!bA&Jd+<55\:r73ZAYLigjAnGbdL3^7?-G>q*'jj^.Pt'V743I\"gQ\apjXEo@PObr^2QI*p:314TUVb-W_@X@k`nG]SKtIa30'!A*&u*a"\63PL.3CDsV5$ZAm*SoP@&.38HUkUU..*E7NEa;0]/(F,:fpZa"0pZ^.2!5PNDE0MatJ:V2.=JJP0Y*m'hjU'OuMbCj&4S$'W5C%fQ-\K5SKH=[T$SGAk!YDS9W.gNCq+,Pg4?8lZ:QAU+!7)U0M6+$9C`*00GQbst92"rQR/CjumR\4]pUVLG?V/%UJnr;6SBG^>E_QkIjRS'h>&lkGH'Ru,p(U9btaucI>.peUX=KXY]kl0YHN^](4qCC^9NmX>t4/Lq6%S+]Jp(V/@%ATH.VMGsePEnDC[DFsSXrh\""TaO%=N=WDIjCQc0I[a]>3p>82sq9#XOo<.3^X,mk/t9=_R3M\;=W:su8oi<_#Pk[L`$qOAFuEFr>3_[[tE$Z5]J-bTP3iZm4dWh-:\XOr7U["Yd5Ahp7kdXtbaEL3n]74jfFeTR7[ff,S66s.9=";*.Zifpj,'jC_k!1$C'F!\^2BoB6Q`\JpLXp\R$U&icC.!Pe4JASIs,'YV?m!Q[i:K99gqaS`d*m='iVR#C;R%X@N?[ZXC>hoYKiMdJ&5oMeYd>Kf\j]X"PDb9Fj);6d_1";aB9KFer-fSdQJ<&:gnZZa[X:u]c$]AV]c]1L^lM[n4(9/aQ[YTHeWE+hSQMOhRss?YJX02.?#;@HNrrnm4DQagAYhJ-Ga?TWQA4s1$Ncdqm&nf.tXDN]'^/bgCB7Q>rTRlI657'!F"]22`nDDe6f]>DERAJ%c_8%g]%X_:]9_?#.EpZnC2r9p-\8bQdRSR`[q9bD=I;a!^:eFd.Ql:n&E^/me/6@!tJ\T!]D%h4N$VnMlsZHZH$oDeY3!t-(!H\!?XEEB5Z\pJ$ZW)('~>endstream +endobj +9 0 obj +<< +/PrintScaling /None +>> +endobj +xref +0 10 +0000000000 65535 f +0000000061 00000 n +0000000102 00000 n +0000000209 00000 n +0000000321 00000 n +0000000514 00000 n +0000000607 00000 n +0000000914 00000 n +0000000973 00000 n +0000003118 00000 n +trailer +<< +/ID +[] +% ReportLab generated PDF document -- digest (opensource) + +/Info 6 0 R +/Root 5 0 R +/Size 10 +>> +startxref +3159 +%%EOF diff --git a/tools/build_hand_lite.py b/tools/build_hand_lite.py new file mode 100644 index 0000000000..0b5c91b55c --- /dev/null +++ b/tools/build_hand_lite.py @@ -0,0 +1,69 @@ +"""Build the pinned lite-palm/lite-landmark MediaPipe bundle (mediapipe==0.10.21).""" +import argparse +import hashlib +import io +from pathlib import Path +import zipfile + +FULL_SHA = 'fbc2a30080c3c557093b5ddfc334698132eb341044ccee322ccf8bcf3607cde1' +LITE_SHA = 'd7fde8ac11f8ce03f8663775bfc323f4fc9f2a38062b4f4efa142874ef5b2a48' +PALM_SHA = 'e9a4aaddf90dda56a87235303cf00e4c2d3fb28725f68fd88772997dac905c18' + +def write_entry(archive, name, data): + entry = zipfile.ZipInfo(name, (1980, 1, 1, 0, 0, 0)) + entry.create_system = 3 + entry.external_attr = 0o100644 << 16 + archive.writestr(entry, data) + +def canonicalize_associated_files(data): + with zipfile.ZipFile(io.BytesIO(data)) as archive: + entries = archive.infolist() + if not entries: + return data + prefix = data[:min(entry.header_offset for entry in entries)] + files = {entry.filename: archive.read(entry) for entry in entries} + output = io.BytesIO(prefix) + with zipfile.ZipFile(output, 'a', compression=zipfile.ZIP_STORED) as archive: + for name in sorted(files): + write_entry(archive, name, files[name]) + return output.getvalue() + +def build(full, lite, palm, output): + import mediapipe + from mediapipe.tasks.python.metadata import metadata + from mediapipe.tasks.metadata import schema_py_generated as schema + if mediapipe.__version__ != '0.10.21': + raise ValueError('Use mediapipe==0.10.21 for reproducible metadata') + for path, expected in [(full, FULL_SHA), (lite, LITE_SHA), (palm, PALM_SHA)]: + if hashlib.sha256(path.read_bytes()).hexdigest() != expected: + raise ValueError(f'Model source checksum mismatch: {path}') + with zipfile.ZipFile(full) as task: + references = {name: task.read(name) for name in ['hand_detector.tflite', 'hand_landmarks_detector.tflite']} + def contract(data): + graph = schema.Model.GetRootAsModel(data, 0).Subgraphs(0) + return [[(graph.Tensors(int(i)).Name(), graph.Tensors(int(i)).ShapeAsNumpy().tolist(), graph.Tensors(int(i)).Type()) + for i in indices] for indices in (graph.InputsAsNumpy(), graph.OutputsAsNumpy())] + models = {} + for name, path in [('hand_detector.tflite', palm), ('hand_landmarks_detector.tflite', lite)]: + data = path.read_bytes() + reference = references[name] + if contract(data) != contract(reference): + raise ValueError(f'Lite tensor contract differs: {name}') + populator = metadata.MetadataPopulator.with_model_buffer(data) + populator.load_metadata_and_associated_files(reference) + populator.populate() + models[name] = canonicalize_associated_files(populator.get_model_buffer()) + output.parent.mkdir(parents=True, exist_ok=True) + with zipfile.ZipFile(output, 'w', compression=zipfile.ZIP_STORED) as task: + for name, data in models.items(): + write_entry(task, name, data) + print(hashlib.sha256(output.read_bytes()).hexdigest()) + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--full', type=Path, default=Path('app/src/main/assets/models/hand_landmarker.task')) + parser.add_argument('--lite', type=Path, required=True, help='Pinned hand_landmark_lite.tflite from storage.googleapis.com/mediapipe-assets/') + parser.add_argument('--palm', type=Path, required=True, help='Pinned palm_detection_lite.tflite from storage.googleapis.com/mediapipe-assets/') + parser.add_argument('--output', type=Path, default=Path('app/src/main/assets/models/hand_landmarker_lite.task')) + args = parser.parse_args() + build(args.full, args.lite, args.palm, args.output) diff --git a/tools/build_rgb_uvc.py b/tools/build_rgb_uvc.py new file mode 100644 index 0000000000..634059804b --- /dev/null +++ b/tools/build_rgb_uvc.py @@ -0,0 +1,179 @@ +"""Build checksum-pinned Android RGB UVC libraries and their fault-injection test.""" +import argparse +import hashlib +import json +import os +from pathlib import Path +import shutil +import subprocess +import tarfile +import urllib.request +import zipfile + + +ROOT = Path(__file__).resolve().parents[1] +RECIPES = ROOT / 'tools/uvc' +PACKAGES = ( + {'name': 'libusb', 'version': '1.0.30', 'license': 'LGPL-2.1-or-later', + 'url': 'https://github.com/libusb/libusb/releases/download/v1.0.30/libusb-1.0.30.tar.bz2', + 'archive': 'libusb-1.0.30.tar.bz2', + 'sha256': 'fea36f34f9156400209595e300840767ab1a385ede1dc7ee893015aea9c6dbaf'}, + {'name': 'libuvc', 'version': '0.0.8', 'license': 'BSD-3-Clause', + 'url': 'https://github.com/libuvc/libuvc/archive/refs/tags/v0.0.8.zip', + 'archive': 'libuvc-0.0.8.zip', + 'sha256': '67922938ad81eb82b8ce14576f15a68ac75e30af738728a1f3070b6bbc938bce'}, +) + + +def sha256(path): + return hashlib.sha256(path.read_bytes()).hexdigest() + + +def download(package, cache): + archive = cache / package['archive'] + if not archive.exists(): + request = urllib.request.Request(package['url'], headers={'User-Agent': 'DroidDeckXR-UVC-Build'}) + with urllib.request.urlopen(request, timeout=60) as response: + payload = response.read() + if hashlib.sha256(payload).hexdigest() != package['sha256']: + raise ValueError(f"Downloaded checksum mismatch: {package['archive']}") + archive.write_bytes(payload) + if sha256(archive) != package['sha256']: + raise ValueError(f'Cached checksum mismatch: {archive}') + return archive + + +def extract(archive, destination): + if archive.suffix == '.zip': + with zipfile.ZipFile(archive) as bundle: + for item in bundle.infolist(): + (destination / item.filename).resolve().relative_to(destination.resolve()) + if (item.external_attr >> 16) & 0o170000 == 0o120000: + raise ValueError('Symlink in ZIP archive') + bundle.extractall(destination) + else: + with tarfile.open(archive) as bundle: + bundle.extractall(destination, filter='data') + + +def patch_source(source, patch): + old, new = [], [] + content = source.read_text(encoding='utf-8') + hunks = [] + for line in patch.read_text(encoding='utf-8').splitlines(keepends=True): + if line.startswith(('--- ', '+++ ')): + continue + if line.startswith('@@ '): + if old or new: + hunks.append((''.join(old), ''.join(new))) + old, new = [], [] + elif line.startswith(' '): + old.append(line[1:]) + new.append(line[1:]) + elif line.startswith('-'): + old.append(line[1:]) + elif line.startswith('+'): + new.append(line[1:]) + else: + raise ValueError(f'Unsupported patch line: {line!r}') + hunks.append((''.join(old), ''.join(new))) + for before, after in hunks: + if not before or content.count(before) != 1: + raise ValueError(f'Patch context mismatch: {source}') + content = content.replace(before, after, 1) + source.write_text(content, encoding='utf-8', newline='\n') + + +def run(command, log): + result = subprocess.run([str(part) for part in command], stdout=subprocess.PIPE, + stderr=subprocess.STDOUT, text=True, encoding='utf-8') + log.write_text(result.stdout, encoding='utf-8') + print(result.stdout, end='') + result.check_returncode() + + +def build(args): + output, cache = args.output.resolve(), args.cache.resolve() + source, binary, dist = output / 'src', output / 'android-arm64', output / 'dist' + for folder in (output, cache, source): + folder.mkdir(parents=True, exist_ok=True) + for package in PACKAGES: + extract(download(package, cache), source) + patch = RECIPES / 'libuvc-submit-failure.patch' + stream = source / 'libuvc-0.0.8/src/stream.c' + patch_source(stream, patch) + + ndk, cmake = args.ndk.resolve(), args.cmake.resolve() + ninja = args.ninja.resolve() if args.ninja else cmake.parent / ('ninja.exe' if os.name == 'nt' else 'ninja') + configure = [cmake, '-S', RECIPES, '-B', binary, '-G', 'Ninja', + f'-DCMAKE_MAKE_PROGRAM={ninja.as_posix()}', + f'-DCMAKE_TOOLCHAIN_FILE={(ndk / "build/cmake/android.toolchain.cmake").as_posix()}', + f'-DRGB_UVC_SOURCE_ROOT={source.as_posix()}', '-DANDROID_ABI=arm64-v8a', + '-DANDROID_PLATFORM=android-26', '-DANDROID_STL=c++_static', + '-DCMAKE_BUILD_TYPE=RelWithDebInfo'] + compile_command = [cmake, '--build', binary, '--parallel', str(args.jobs)] + run(configure, output / 'configure.log') + run(compile_command, output / 'build.log') + + copies = { + binary / 'libusb.so': dist / 'arm64-v8a/libusb.so', + binary / 'libuvc.a': dist / 'arm64-v8a/libuvc.a', + binary / 'uvc_submit_failure_test': dist / 'arm64-v8a/uvc_submit_failure_test', + source / 'libusb-1.0.30/libusb/libusb.h': dist / 'include/libusb.h', + source / 'libuvc-0.0.8/include/libuvc/libuvc.h': dist / 'include/libuvc/libuvc.h', + binary / 'generated/libuvc/libuvc_config.h': dist / 'include/libuvc/libuvc_config.h', + source / 'libusb-1.0.30/COPYING': dist / 'licenses/libusb-COPYING', + source / 'libuvc-0.0.8/LICENSE.txt': dist / 'licenses/libuvc-LICENSE.txt', + } + for original, target in copies.items(): + target.parent.mkdir(parents=True, exist_ok=True) + shutil.copyfile(original, target) + prebuilt = list((ndk / 'toolchains/llvm/prebuilt').iterdir()) + if len(prebuilt) != 1: + raise ValueError(f'Expected one NDK host toolchain: {prebuilt}') + readelf = prebuilt[0] / 'bin' / ('llvm-readelf.exe' if os.name == 'nt' else 'llvm-readelf') + reports = [] + for name in ('libusb.so', 'uvc_submit_failure_test'): + result = subprocess.check_output([str(readelf), '-h', '-l', '-d', str(binary / name)], + text=True, encoding='utf-8') + if 'AArch64' not in result or 'TEXTREL' in result: + raise ValueError(f'Unexpected ELF ABI or text relocations: {name}') + loads = [line for line in result.splitlines() if line.lstrip().startswith('LOAD')] + if not loads or any(not line.rstrip().endswith('0x4000') for line in loads): + raise ValueError(f'ELF must use 16 KiB LOAD alignment: {name}') + if name == 'uvc_submit_failure_test' and ('[libusb.so]' not in result or 'libglasses' in result): + raise ValueError('Fault test must depend on standalone libusb') + reports.append(result) + (output / 'elf-validation.txt').write_text('\n'.join(reports), encoding='utf-8') + manifest = { + 'packages': PACKAGES, + 'patch': {'path': str(patch.relative_to(ROOT)), 'sha256': sha256(patch), + 'sourceSha256': sha256(stream), + 'reason': 'Preserve USB submission errors; remove unsubmitted transfers under cb_mutex, then cancel/drain submitted transfers and join the callback thread.'}, + 'build': {'ndk': str(ndk), 'ndkSourceProperties': (ndk / 'source.properties').read_text(encoding='utf-8'), + 'configure': [str(part) for part in configure], 'compile': [str(part) for part in compile_command], + 'api': 26, 'abi': 'arm64-v8a', 'pic': True, 'queueBuffers': 8, + 'isoPacketsPerTransferMaximum': 32, 'jpegConversion': False, + 'libusbShared': True, 'libuvcStatic': True, + 'recipeHashes': {str(path.relative_to(ROOT)): sha256(path) for path in + (Path(__file__), RECIPES / 'CMakeLists.txt', RECIPES / 'submit_failure_test.cpp')}}, + 'validation': {'nativeBuild': 'passed', 'linkNoUndefined': 'passed', 'machine': 'AArch64', + 'loadAlignmentBytes': 16384, 'textRelocations': False, + 'deviceRuntimeTest': 'not run by build script'}, + 'artifacts': [{'path': str(path.relative_to(output)), 'sha256': sha256(path), 'size': path.stat().st_size} + for path in copies.values()], + } + (output / 'provenance.json').write_text(json.dumps(manifest, indent=2) + '\n', encoding='utf-8') + print(f'Libraries and headers: {dist}') + print(f'Provenance: {output / "provenance.json"}') + + +if __name__ == '__main__': + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--ndk', type=Path, required=True) + parser.add_argument('--cmake', type=Path, required=True) + parser.add_argument('--ninja', type=Path) + parser.add_argument('--output', type=Path, default=ROOT / 'build/rgb-uvc') + parser.add_argument('--cache', type=Path, default=ROOT / 'build/uvc-source-cache') + parser.add_argument('--jobs', type=int, default=4) + build(parser.parse_args()) diff --git a/tools/cardboard/test_cardboard_params.c b/tools/cardboard/test_cardboard_params.c index 3c3b8453a8..8b284cf6ac 100644 --- a/tools/cardboard/test_cardboard_params.c +++ b/tools/cardboard/test_cardboard_params.c @@ -1,6 +1,7 @@ #include "cardboard.h" #include #include +#include static int failures; #define CHECK(c) do { if (!(c)) { printf("FAIL %s:%d: %s\n", __FILE__, __LINE__, #c); failures++; } } while (0) @@ -54,10 +55,59 @@ int main(void) { cardboard_push_constants(&q, pose, 3840, 1080, 3840, 1080, pc); CHECK(near(pc[14], tanf(glasses_fovs[i] * 0.5f * (float)M_PI / 180.0f))); } + + const struct cardboard_params screen = { + .enabled = 1, .source = CARDBOARD_SOURCE_SCREEN, .ipd_m = 0.064f, + .screen_dist_m = 3.0f, .screen_width_m = 2.0f, .fov_deg = 25.8f, + }; + const int source_sizes[][2] = {{1280, 720}, {1600, 900}, {1920, 1080}}; + const int panel_heights[] = {1080, 1200}; + for (unsigned panel = 0; panel < sizeof(panel_heights) / sizeof(panel_heights[0]); panel++) { + float native[24]; + const int height = panel_heights[panel]; + cardboard_push_constants(&screen, pose, 1920, 1080, 3840, height, native); + for (unsigned size = 0; size < sizeof(source_sizes) / sizeof(source_sizes[0]); size++) { + cardboard_push_constants(&screen, pose, source_sizes[size][0], source_sizes[size][1], 3840, height, pc); + for (unsigned field = 0; field < 24; field++) CHECK(near(pc[field], native[field])); + CHECK(near(pc[17], 16.0f / 9.0f)); + CHECK(near(pc[18], CARDBOARD_SOURCE_SCREEN)); + CHECK(near(pc[19], 1920.0f / height)); + CHECK(near(pc[20], 0.0f)); + } + } + q.source = CARDBOARD_SOURCE_FLAT; + cardboard_clamp(&q); + CHECK(q.source == CARDBOARD_SOURCE_FLAT); + for (unsigned panel = 0; panel < sizeof(panel_heights) / sizeof(panel_heights[0]); panel++) { + for (unsigned size = 0; size < sizeof(source_sizes) / sizeof(source_sizes[0]); size++) { + cardboard_push_constants(&q, pose, source_sizes[size][0], source_sizes[size][1], 3840, panel_heights[panel], pc); + CHECK(near(pc[17], 16.0f / 9.0f)); + CHECK(near(pc[18], CARDBOARD_SOURCE_FLAT)); + CHECK(near(pc[19], 1920.0f / panel_heights[panel])); + CHECK(near(pc[20], 0.0f)); + } + } q.fov_deg = 0.0f; cardboard_clamp(&q); CHECK(q.fov_deg > 0.0f && q.fov_deg < glasses_fovs[0]); + const float translation[3] = {0.25f, -0.3f, 0.5f}; + q.source = CARDBOARD_SOURCE_SCREEN; + cardboard_push_constants(&q, pose, 1920, 1080, 3840, 1200, pc); + float original[24]; memcpy(original, pc, sizeof(pc)); + cardboard_push_translation(&q, translation, pc); + for (int i = 0; i < 21; ++i) CHECK(near(pc[i], original[i])); + for (int i = 0; i < 3; ++i) CHECK(near(pc[21+i], translation[i])); + q.source = CARDBOARD_SOURCE_SBS; + cardboard_push_translation(&q, translation, pc); + CHECK(near(pc[21], 0) && near(pc[22], 0) && near(pc[23], 0)); + q.source = CARDBOARD_SOURCE_FLAT; + cardboard_push_translation(&q, translation, pc); + CHECK(near(pc[21], 0) && near(pc[22], 0) && near(pc[23], 0)); + q.source = CARDBOARD_SOURCE_SCREEN; + const float zero[3] = {0}; + cardboard_push_translation(&q, zero, pc); + for (int i = 0; i < 24; ++i) CHECK(near(pc[i], original[i])); if (failures) return 1; printf("PASS: cardboard params\n"); return 0; diff --git a/tools/check_glasses_menu_shader.py b/tools/check_glasses_menu_shader.py new file mode 100644 index 0000000000..1b775b3e33 --- /dev/null +++ b/tools/check_glasses_menu_shader.py @@ -0,0 +1,205 @@ +#!/usr/bin/env python3 +"""Compile and render the tracked-menu GLES shaders with headless Mesa (opt-in).""" + +import argparse +import ctypes as c +import hashlib +import json +import math +import os +import pathlib +import re +import struct +import zlib + + +def main(): + os.environ.setdefault('EGL_PLATFORM', 'surfaceless') + os.environ.setdefault('LIBGL_ALWAYS_SOFTWARE', '1') + os.environ.setdefault('MESA_GLES_VERSION_OVERRIDE', '2.0') + root = pathlib.Path(__file__).resolve().parents[1] + parser = argparse.ArgumentParser(description=__doc__) + parser.add_argument('--output-dir', type=pathlib.Path, default=root / 'build/glasses-menu-shader') + args = parser.parse_args() + out = args.output_dir.resolve() + out.mkdir(parents=True, exist_ok=True) + source_path = root / 'app/src/main/java/com/droiddeck/launcher/glasses/GlassesMenuSurface.kt' + source = source_path.read_text() + shaders = {name: re.search(r'private const val '+name+r' = """(.*?)"""', source, re.S).group(1).encode() + for name in ('VERTEX', 'FRAGMENT')} + try: + egl = c.CDLL('libEGL.so.1') + gl = c.CDLL('libGLESv2.so.2') + except OSError as error: + raise SystemExit('This opt-in check needs Linux EGL/GLES and Mesa software rendering. ' + 'On Debian/Ubuntu install libegl1 libegl-mesa0 libgles2 libgl1-mesa-dri. ' + f'Library load failed: {error}') from error + + def bind(lib, name, result, *args): + fn = getattr(lib, name) + fn.restype, fn.argtypes = result, args + return fn + + P, I, U, F = c.c_void_p, c.c_int, c.c_uint, c.c_float + eglGetDisplay = bind(egl, 'eglGetDisplay', P, P) + eglInitialize = bind(egl, 'eglInitialize', U, P, c.POINTER(I), c.POINTER(I)) + eglChooseConfig = bind(egl, 'eglChooseConfig', U, P, c.POINTER(I), c.POINTER(P), I, c.POINTER(I)) + eglCreatePbufferSurface = bind(egl, 'eglCreatePbufferSurface', P, P, P, c.POINTER(I)) + eglCreateContext = bind(egl, 'eglCreateContext', P, P, P, P, c.POINTER(I)) + eglMakeCurrent = bind(egl, 'eglMakeCurrent', U, P, P, P, P) + eglQueryString = bind(egl, 'eglQueryString', c.c_char_p, P, I) + eglGetProcAddress = bind(egl, 'eglGetProcAddress', P, c.c_char_p) + display = eglGetDisplay(None) + major, minor = I(), I() + assert eglInitialize(display, c.byref(major), c.byref(minor)) + attrs = (I * 15)(0x3033, 1, 0x3040, 4, 0x3024, 8, 0x3023, 8, 0x3022, 8, 0x3021, 8, 0x3025, 0, 0x3038) + config, count = P(), I() + assert eglChooseConfig(display, attrs, c.byref(config), 1, c.byref(count)) and count.value + surface = eglCreatePbufferSurface(display, config, (I * 5)(0x3057, 512, 0x3056, 256, 0x3038)) + context = eglCreateContext(display, config, None, (I * 3)(0x3098, 2, 0x3038)) + assert surface and context and eglMakeCurrent(display, surface, surface, context) + getString = bind(gl, 'glGetString', c.c_char_p, U) + getError = bind(gl, 'glGetError', U) + metadata = {'source_sha256': hashlib.sha256(source.encode()).hexdigest(), + 'shader_sha256': {key: hashlib.sha256(value).hexdigest() for key, value in shaders.items()}, + 'egl': eglQueryString(display, 0x3054).decode(), + 'gles': getString(0x1F02).decode(), 'renderer': getString(0x1F01).decode(), + 'assumption': 'External texture contains top-row-first Canvas buffer pixels; consumer transform flips Y, as Android GLConsumer does. Device SurfaceTexture/Canvas integration still needs validation.'} + assert b'GL_OES_EGL_image_external' in getString(0x1F03) + createShader = bind(gl, 'glCreateShader', U, U) + shaderSource = bind(gl, 'glShaderSource', None, U, I, c.POINTER(c.c_char_p), c.POINTER(I)) + compileShader = bind(gl, 'glCompileShader', None, U) + getShaderiv = bind(gl, 'glGetShaderiv', None, U, U, c.POINTER(I)) + getShaderLog = bind(gl, 'glGetShaderInfoLog', None, U, I, c.POINTER(I), c.c_char_p) + compiled = [] + for name, kind in [('VERTEX', 0x8B31), ('FRAGMENT', 0x8B30)]: + shader = createShader(kind) + text = c.c_char_p(shaders[name]) + shaderSource(shader, 1, c.byref(text), None) + compileShader(shader) + status, log = I(), c.create_string_buffer(8192) + getShaderiv(shader, 0x8B81, c.byref(status)) + getShaderLog(shader, len(log), None, log) + assert status.value, name + ': ' + log.value.decode() + compiled.append(shader) + createProgram = bind(gl, 'glCreateProgram', U) + attachShader = bind(gl, 'glAttachShader', None, U, U) + linkProgram = bind(gl, 'glLinkProgram', None, U) + getProgramiv = bind(gl, 'glGetProgramiv', None, U, U, c.POINTER(I)) + getProgramLog = bind(gl, 'glGetProgramInfoLog', None, U, I, c.POINTER(I), c.c_char_p) + program = createProgram() + for shader in compiled: + attachShader(program, shader) + linkProgram(program) + status, log = I(), c.create_string_buffer(8192) + getProgramiv(program, 0x8B82, c.byref(status)) + getProgramLog(program, len(log), None, log) + assert status.value, log.value.decode() + useProgram = bind(gl, 'glUseProgram', None, U) + useProgram(program) + getUniform = bind(gl, 'glGetUniformLocation', I, U, c.c_char_p) + uniform1i = bind(gl, 'glUniform1i', None, I, I) + uniform3f = bind(gl, 'glUniform3f', None, I, F, F, F) + uniform4f = bind(gl, 'glUniform4f', None, I, F, F, F, F) + uniformMatrix4 = bind(gl, 'glUniformMatrix4fv', None, I, I, U, c.POINTER(F)) + loc = lambda name: getUniform(program, name.encode()) + uniform1i(loc('uTexture'), 0) + flip = (F * 16)(1,0,0,0, 0,-1,0,0, 0,0,1,0, 0,1,0,1) + uniformMatrix4(loc('uTextureMatrix'), 1, 0, flip) + + genTextures = bind(gl, 'glGenTextures', None, I, c.POINTER(U)) + bindTexture = bind(gl, 'glBindTexture', None, U, U) + texParameteri = bind(gl, 'glTexParameteri', None, U, U, I) + texImage2D = bind(gl, 'glTexImage2D', None, U, I, I, I, I, I, U, U, P) + names = (U * 2)() + genTextures(2, names) + bindTexture(0x0DE1, names[0]) + pixels = bytes(value for y in range(256) for x in range(256) for value in (x, y, 37, 255)) + pixel_data = (c.c_ubyte * len(pixels)).from_buffer_copy(pixels) + texImage2D(0x0DE1, 0, 0x1908, 256, 256, 0, 0x1908, 0x1401, pixel_data) + for param, value in [(0x2801,0x2601),(0x2800,0x2601),(0x2802,0x812F),(0x2803,0x812F)]: + texParameteri(0x0DE1, param, value) + createImage = c.CFUNCTYPE(P, P, P, U, P, c.POINTER(I))(eglGetProcAddress(b'eglCreateImageKHR')) + imageTarget = c.CFUNCTYPE(None, U, P)(eglGetProcAddress(b'glEGLImageTargetTexture2DOES')) + image = createImage(display, context, 0x30B1, P(names[0]), (I * 3)(0x30BC, 0, 0x3038)) + assert image + bindTexture(0x8D65, names[1]) + imageTarget(0x8D65, image) + for param, value in [(0x2801,0x2601),(0x2800,0x2601),(0x2802,0x812F),(0x2803,0x812F)]: + texParameteri(0x8D65, param, value) + assert getError() == 0 + getAttrib = bind(gl, 'glGetAttribLocation', I, U, c.c_char_p) + enableAttrib = bind(gl, 'glEnableVertexAttribArray', None, U) + attribPointer = bind(gl, 'glVertexAttribPointer', None, U, I, U, U, I, P) + vertices = (F * 8)(-1,-1, 1,-1, -1,1, 1,1) + position = getAttrib(program, b'aPosition') + enableAttrib(position) + attribPointer(position, 2, 0x1406, 0, 0, vertices) + viewport = bind(gl, 'glViewport', None, I, I, I, I) + draw = bind(gl, 'glDrawArrays', None, U, I, I) + read = bind(gl, 'glReadPixels', None, I, I, I, I, U, U, P) + finish = bind(gl, 'glFinish', None) + cases = [] + + def render(name, mono=True, position=(0,0,0), yaw=0, width=512, height=256, coords=((64,32),(448,32),(64,224),(448,224)), backdrop=False): + viewport(0, 0, width, height) + cs, sn = math.cos(yaw), math.sin(yaw) + for row, values in enumerate(((cs,0,sn),(0,1,0),(-sn,0,cs))): + uniform3f(loc('uRotation'+str(row)), *values) + uniform3f(loc('uHead'), *position) + uniform3f(loc('uScreen'), 1, 1, 2) + uniform4f(loc('uOptics'), .5, width/height/(1 if mono else 2), 0 if mono else .032, 1 if mono else 0) + draw(0x0005, 0, 4) + finish() + assert getError() == 0 + actual = (c.c_ubyte * (width*height*4))() + read(0,0,width,height,0x1908,0x1401,actual) + samples = [] + for x, y in coords: + # Readback is GL bottom-up; coordinates below are image top-left. + offset = ((height-1-y)*width+x)*4 + rgb = list(actual[offset:offset+3]) + eye = 0 if mono or x < width/2 else 1 + ux = (x+.5)/width if mono else (x+.5)/(width/2)-eye + vy = (y+.5)/height + rayx = (ux-.5)*(width/height/(1 if mono else 2)) + rayy = .5-vy + dx, dy, dz = cs*rayx-sn, rayy, -sn*rayx-cs + eo = 0 if mono else (-.032 if eye == 0 else .032) + ox, oy, oz = position[0]+cs*eo, position[1], position[2]-sn*eo + t = (-1-oz)/dz if dz else -1 + uv = ((ox+dx*t)*.5+.5, -(oy+dy*t)+.5) + valid = dz < -.0001 and t > 0 and all(0 <= v <= 1 for v in uv) and not backdrop + expected = [round(max(0,min(255,v*256-.5))) for v in uv]+[37] if valid else [4,4,5] + assert all(abs(a-b) <= 2 for a,b in zip(rgb,expected)), (name,x,y,rgb,expected,uv) + samples.append({'at':[x,y],'rgb':rgb,'expected':expected}) + cases.append({'name':name,'samples':samples}) + if name == 'mono_upright': + rows = bytearray() + for y in range(height-1,-1,-1): + for x in range(width): + start=(y*width+x)*4 + rows.extend(actual[start:start+3]) + (out/'menu-shader-mono.ppm').write_bytes(f'P6\n{width} {height}\n255\n'.encode()+rows) + def chunk(name, data): + return struct.pack('>I',len(data))+name+data+struct.pack('>I',zlib.crc32(name+data)&0xffffffff) + scanlines=b''.join(b'\x00'+rows[y*width*3:(y+1)*width*3] for y in range(height)) + (out/'menu-shader-mono.png').write_bytes(b'\x89PNG\r\n\x1a\n'+ + chunk(b'IHDR',struct.pack('>IIBBBBB',width,height,8,2,0,0,0))+ + chunk(b'IDAT',zlib.compress(scanlines))+chunk(b'IEND',b'')) + + render('mono_upright') + render('sbs_both_eyes', mono=False, width=512, height=128, + coords=((32,16),(224,16),(32,112),(224,112),(288,16),(480,16),(288,112),(480,112),(128,64),(384,64))) + render('six_dof_translation', position=(.2,.1,.1), coords=((256,128),(200,96),(300,160))) + render('row_major_yaw', yaw=math.radians(10), coords=((256,128),(200,96),(300,160))) + render('behind_plane', position=(0,0,-2), coords=((256,128),), backdrop=True) + render('back_facing', yaw=math.pi, coords=((256,128),), backdrop=True) + metadata['cases'] = cases + metadata['result'] = 'PASS' + (out/'menu-shader-validation.json').write_text(json.dumps(metadata, indent=2)+'\n') + print(json.dumps(metadata, indent=2), flush=True) + + +if __name__ == '__main__': + main() diff --git a/tools/droiddeckctl b/tools/droiddeckctl index d0a5bbb795..9544e65c7d 100755 --- a/tools/droiddeckctl +++ b/tools/droiddeckctl @@ -676,6 +676,10 @@ def execute(args: argparse.Namespace, adb: str, serial: str) -> dict: request["mode"] = args.mode elif args.glasses_op == "imu": request["ms"] = args.ms + elif args.glasses_op == "spatial-diagnostics": + request["enabled"] = not args.off + elif args.glasses_op == "spatial-recenter": + request["screen"] = args.screen elif args.glasses_op == "raw": request.update(msgId=args.msg_id, payload=args.payload or "") return add_serial(checked(provider_call(adb, serial, "glasses", request=request), "GLASSES_FAILED"), serial) @@ -853,7 +857,7 @@ def build_parser() -> argparse.ArgumentParser: glasses_ops = glasses.add_subparsers(dest="glasses_op") glasses_ops.add_parser("status") glasses_ops.add_parser("allow", help="ask for USB control of the glasses again") - glasses_set = glasses_ops.add_parser("set", help="refreshHz, sbsHz, brightness, volume, sunblock, 3d, gameOnGlasses, headTracking, auto3d, picture3d, screenWidthDm, screenDistanceDm, vrFovDeg") + glasses_set = glasses_ops.add_parser("set", help="refreshHz, sbsHz, resolution2d, resolution3d, resolutionVr (auto or WIDTHxHEIGHT per eye), brightness, volume, sunblock, 3d, 3dof, gameOnGlasses, headTracking, auto3d, picture3d, screenWidthDm, screenDistanceDm, vrFovDeg") glasses_set.add_argument("key") glasses_set.add_argument("value") glasses_sim = glasses_ops.add_parser("simulate", help="feed a moving head pose (yaw, pitch and roll sweeps), or hold one") @@ -862,6 +866,12 @@ def build_parser() -> argparse.ArgumentParser: glasses_sim.add_argument("--pitch", type=float, help="hold this pitch (degrees, down positive) instead of sweeping") glasses_ops.add_parser("stop-simulate") glasses_ops.add_parser("query", help="ask the glasses for their display mode, brightness, volume and IMU state") + spatial_diagnostics = glasses_ops.add_parser("spatial-diagnostics", help="start stereo diagnostics without saving images") + spatial_diagnostics.add_argument("--off", action="store_true") + spatial_recenter = glasses_ops.add_parser("spatial-recenter", help="recenter the current spatial origin") + spatial_recenter.add_argument("--screen", action="store_true") + glasses_ops.add_parser("spatial-floor", help="set floor using configured eye height") + glasses_ops.add_parser("spatial-restart", help="restart the provider for explicit tracking recovery") glasses_mode = glasses_ops.add_parser("mode", help="send a display mode byte, e.g. 0x31 (1080p60), 0x34 (1080p120), 0x32 (3D)") glasses_mode.add_argument("mode") glasses_imu = glasses_ops.add_parser("imu", help="stream the glasses' IMU for a moment and show what it reports") diff --git a/tools/linuxfs/build-x86-preloads.sh b/tools/linuxfs/build-x86-preloads.sh index 8a43941af8..61abcb3216 100755 --- a/tools/linuxfs/build-x86-preloads.sh +++ b/tools/linuxfs/build-x86-preloads.sh @@ -26,7 +26,7 @@ for arch in x86_64 i386; do fi done done -for target in x86_64/faultreport i386/faultreport x86_64/thunkaudit; do +for target in x86_64/faultreport i386/faultreport; do arch=${target%/*} name=${target#*/} case $arch in x86_64) bits=-m64 ;; @@ -51,11 +51,14 @@ if objdump -p "$lib" | grep -q NEEDED || [ "$(nm -D --undefined-only "$lib" | aw fi stub=$(mktemp -d) gcc -m64 -shared -nostdlib -Wl,-soname,/usr/lib/x86_64-linux-gnu/libvulkan.so.1 -o "$stub/libvulkan.so.1" -x c /dev/null -gcc -m64 -shared -nostdlib -Wl,-z,nodelete -Wl,--no-as-needed \ - -o "$out/x86_64/libvulkan-thunk.so" -x c /dev/null -x none "$stub/libvulkan.so.1" +lib=$out/x86_64/libvulkan-thunk.so +gcc -m64 -shared -fPIC -O2 -Wall -Wextra -fvisibility=hidden -Wl,-soname,libvulkan.so.1 -Wl,-z,nodelete -Wl,--no-as-needed \ + -o "$lib" tools/linuxfs/fex/vulkanpin.c "$stub/libvulkan.so.1" -ldl rm -rf "$stub" -if ! objdump -p "$out/x86_64/libvulkan-thunk.so" | grep -q 'NEEDED *\/usr/lib/x86_64-linux-gnu/libvulkan\.so\.1$' \ - || ! objdump -p "$out/x86_64/libvulkan-thunk.so" | grep -q 'FLAGS_1 *0x0*8$'; then - echo "$out/x86_64/libvulkan-thunk.so must be nodelete and need only the Vulkan thunk" >&2 +strip --strip-unneeded "$lib" +newest=$(objdump -T "$lib" | grep -o 'GLIBC_2\.[0-9]*' | sort -u -t. -k2,2n | tail -1) +if ! objdump -p "$lib" | grep -q 'NEEDED *\/usr/lib/x86_64-linux-gnu/libvulkan\.so\.1$' \ + || ! objdump -p "$lib" | grep -q 'FLAGS_1 *0x0*8$' || [ "${newest#GLIBC_2.}" -gt 31 ]; then + echo "$lib must be nodelete, need the Vulkan thunk and run on glibc 2.31" >&2 exit 1 fi diff --git a/tools/linuxfs/fex/thunkaudit.c b/tools/linuxfs/fex/thunkaudit.c deleted file mode 100644 index 413ac73ba2..0000000000 --- a/tools/linuxfs/fex/thunkaudit.c +++ /dev/null @@ -1,40 +0,0 @@ -#if !defined(__x86_64__) -#error thunkaudit is built for x86_64 guests only -#endif - -#define LA_SER_ORIG 0x01 - -static const char vulkan_thunk[] = "/usr/lib/x86_64-linux-gnu/libvulkan.so.1"; -static const char vulkan_pin[] = "/usr/lib/x86_64-linux-gnu/droiddeck/libvulkan-thunk.so"; - -static int same(const char *a, const char *b) -{ - while (*a && *a == *b) { - a++; - b++; - } - return *a == *b; -} - -static const char *base_name(const char *path) -{ - const char *name = path; - for (; *path; path++) - if (*path == '/') - name = path + 1; - return name; -} - -__attribute__((visibility("default"))) unsigned int la_version(unsigned int version) -{ - return version; -} - -__attribute__((visibility("default"))) char *la_objsearch(const char *name, unsigned long *cookie, unsigned int flag) -{ - const char *file = base_name(name); - (void)cookie; - if (flag == LA_SER_ORIG && !same(name, vulkan_thunk) && (same(file, "libvulkan.so.1") || same(file, "libvulkan.so"))) - return (char *)vulkan_pin; - return (char *)name; -} diff --git a/tools/linuxfs/fex/vulkanpin.c b/tools/linuxfs/fex/vulkanpin.c new file mode 100644 index 0000000000..45aeb9edb0 --- /dev/null +++ b/tools/linuxfs/fex/vulkanpin.c @@ -0,0 +1,88 @@ +#include +#include +#include + +#ifndef VULKAN_THUNK +#define VULKAN_THUNK "/usr/lib/x86_64-linux-gnu/libvulkan.so.1" +#endif + +#define VK_INCOMPLETE 5 +#define VK_ERROR_INITIALIZATION_FAILED (-3) +#define EXTENSIONS 128 + +typedef int VkResult; +typedef void (*Function)(void); +typedef struct { + char extensionName[256]; + unsigned int specVersion; +} VkExtensionProperties; +typedef VkResult (*Enumerate)(const char *, unsigned int *, VkExtensionProperties *); +typedef Function (*ProcAddr)(void *, const char *); + +/* The driver cannot enumerate devices for an instance with VK_KHR_display, and gamescope's WSI layer aborts on that. */ +static const char *const hidden_extensions[] = { + "VK_KHR_display", + "VK_KHR_get_display_properties2", + "VK_EXT_direct_mode_display", + "VK_EXT_acquire_xlib_display", + "VK_EXT_acquire_drm_display", + "VK_EXT_display_surface_counter", +}; + +static void *thunk(const char *name) +{ + void *library = dlopen(VULKAN_THUNK, RTLD_NOW | RTLD_NOLOAD); + void *found = library ? dlsym(library, name) : NULL; + if (library) + dlclose(library); + return found; +} + +static int hidden(const char *name) +{ + for (size_t i = 0; i < sizeof(hidden_extensions) / sizeof(hidden_extensions[0]); i++) + if (!strcmp(name, hidden_extensions[i])) + return 1; + return 0; +} + +__attribute__((visibility("default"))) VkResult vkEnumerateInstanceExtensionProperties(const char *layer, unsigned int *count, + VkExtensionProperties *properties) +{ + static Enumerate real; + VkExtensionProperties all[EXTENSIONS]; + unsigned int total = EXTENSIONS, kept = 0, room = properties ? *count : 0; + VkResult result; + if (!real) + real = (Enumerate)thunk("vkEnumerateInstanceExtensionProperties"); + if (!real) + return VK_ERROR_INITIALIZATION_FAILED; + result = real(layer, &total, all); + if (result < 0) + return result; + for (unsigned int i = 0; i < total; i++) { + if (hidden(all[i].extensionName)) + continue; + if (properties && kept < room) + memcpy(&properties[kept], &all[i], sizeof(all[i])); + kept++; + } + if (!properties) { + *count = kept; + return result; + } + *count = kept < room ? kept : room; + return kept > room ? VK_INCOMPLETE : result; +} + +__attribute__((visibility("default"))) Function vkGetInstanceProcAddr(void *instance, const char *name) +{ + static ProcAddr real; + if (!strcmp(name, "vkGetInstanceProcAddr")) + return (Function)vkGetInstanceProcAddr; + if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) + return (Function)vkEnumerateInstanceExtensionProperties; + if (!real) + real = (ProcAddr)thunk("vkGetInstanceProcAddr"); + return real ? real(instance, name) : NULL; +} diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex index c05ab928ba..0de377ef0f 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-fex @@ -28,15 +28,25 @@ URUNTIME = "/usr/local/lib/droiddeck/uruntime" HOST_PRELOAD = "/etc/ld.so.preload" FEX_APPID = "3127680" SNIPER_APPID = "1628350" -INSTALL_DIRS = {FEX_APPID: "FEX-Emu", SNIPER_APPID: "SteamLinuxRuntime_sniper"} +SLR4_APPID = "4183110" +INSTALL_DIRS = {FEX_APPID: "FEX-Emu", SNIPER_APPID: "SteamLinuxRuntime_sniper", SLR4_APPID: "SteamLinuxRuntime_4"} MARKER = ".droiddeck-fex" LAYOUT = 1 +ROOTFS_LAYOUT = 1 +ARCH_DIRS = ("x86_64-linux-gnu", "i386-linux-gnu") +INTERPRETERS = ("ld-linux-x86-64.so.2", "ld-linux.so.2") +PROVIDED = frozenset(( + "ld-linux-x86-64.so.2", "ld-linux.so.2", "libc.so.6", "libm.so.6", "libmvec.so.1", "libpthread.so.0", "libdl.so.2", + "librt.so.1", "libutil.so.1", "libresolv.so.2", "libanl.so.1", "libBrokenLocale.so.1", "libnsl.so.1", + "libnss_compat.so.2", "libnss_dns.so.2", "libnss_files.so.2", "libnss_hesiod.so.2", "libthread_db.so.1", + "libmemusage.so", "libpcprofile.so", "libc_malloc_debug.so.0", "gconv", "libstdc++.so.6", "libgcc_s.so.1", +)) +GLIBC_BUILD = re.compile(r"^(?:ld|lib[A-Za-z_]+)-2\.[0-9]+\.so$|^libSegFault\.so$") GUEST_LIBDIRS = (("x86_64", "lib/x86_64-linux-gnu"), ("i386", "lib/i386-linux-gnu")) PRELOAD_NAMES = ("libblsession.so", "libfakeinput.so") FAULT_REPORT = "libfaultreport.so" -THUNK_AUDIT = "libthunkaudit.so" -THUNK_AUDIT_GUEST = "/usr/lib/x86_64-linux-gnu/droiddeck/" + THUNK_AUDIT VULKAN_PIN = "libvulkan-thunk.so" +VULKAN_PIN_DIR = "lib/x86_64-linux-gnu/droiddeck/vulkan" VULKAN_THUNK = "libvulkan-guest.so" RUNTIME_LIBRARIES = (("libc.so.6", b"GLIBC_"), ("libstdc++.so.6", b"GLIBCXX_")) VERSION_NAME = re.compile(rb"GLIBC(?:XX)?_[0-9][0-9.]*[0-9]") @@ -164,15 +174,15 @@ def platform_version(path): return tuple(int(part) for part in re.findall(r"\d+", os.path.basename(path))) -def runtime_platform(): - runtime = app_dir(SNIPER_APPID) +def runtime_platform(appid=SNIPER_APPID, prefix="sniper_platform_"): + runtime = app_dir(appid) if not runtime: return None try: entries = os.listdir(runtime) except OSError: return None - platforms = [os.path.join(runtime, entry) for entry in entries if entry.startswith("sniper_platform_")] + platforms = [os.path.join(runtime, entry) for entry in entries if entry.startswith(prefix)] platforms = [path for path in platforms if os.path.isdir(os.path.join(path, "files")) and os.path.isfile(os.path.join(path, "usr-mtree.txt.gz"))] return max(platforms, key=platform_version, default=None) @@ -234,6 +244,75 @@ def materialize(platform): return True +def graphics_platform(): + return runtime_platform(SLR4_APPID, "steamrt4_platform_") + + +def provides_newer(base, provider): + for name, prefix in RUNTIME_LIBRARIES: + ours = {v for v in version_names(os.path.join(base, "files/lib/x86_64-linux-gnu", name)) if v.startswith(prefix)} + theirs = {v for v in version_names(os.path.join(provider, "files/lib/x86_64-linux-gnu", name)) if v.startswith(prefix)} + if not ours or not theirs or not ours < theirs: + return False + return True + + +def mirror(source, provider, name, target): + if provider and name in PROVIDED and os.path.lexists(os.path.join(provider, name)): + os.symlink(os.path.realpath(os.path.join(provider, name)), os.path.join(target, name)) + return + path = os.path.join(source, name) + link = os.readlink(path) if os.path.islink(path) else None + if link and GLIBC_BUILD.match(os.path.basename(link)): + if name not in INTERPRETERS: + return + link = os.path.join(os.path.dirname(link), name) + if provider and GLIBC_BUILD.match(name): + return + if link and not link.startswith("/"): + os.symlink(link, os.path.join(target, name)) + else: + os.symlink(os.path.realpath(path), os.path.join(target, name)) + + +def build_rootfs(base, provider): + """The runtime with glibc and libstdc++ taken from a newer one, which FEX's GL and Vulkan thunks are built against.""" + base_files, provider_files = os.path.join(base, "files"), os.path.join(provider, "files") + rootfs = os.path.join(STATE, "rootfs") + stamp = "%d\n%s\n%s%s\n%s" % (ROOTFS_LAYOUT, os.path.realpath(base), read_text(os.path.join(base_files, MARKER)) or "", + os.path.realpath(provider), read_text(os.path.join(provider_files, MARKER)) or "") + if read_text(os.path.join(rootfs, MARKER)) == stamp: + return False + for entry in os.listdir(STATE): + if entry.startswith("rootfs."): + shutil.rmtree(os.path.join(STATE, entry), ignore_errors=True) + tmp = "%s.%d.tmp" % (rootfs, os.getpid()) + os.makedirs(tmp) + for entry in os.listdir(base_files): + if entry not in ("lib", "lib64", "usr", MARKER): + os.symlink(os.path.realpath(os.path.join(base_files, entry)), os.path.join(tmp, entry)) + os.symlink(".", os.path.join(tmp, "usr")) + for top in ("lib", "lib64"): + source = os.path.join(base_files, top) + os.makedirs(os.path.join(tmp, top)) + for entry in os.listdir(source) if os.path.isdir(source) else (): + path = os.path.join(source, entry) + if entry in ARCH_DIRS and os.path.isdir(path) and not os.path.islink(path): + provided = os.path.join(provider_files, top, entry) + os.makedirs(os.path.join(tmp, top, entry)) + for name in set(os.listdir(path)) | {name for name in PROVIDED if os.path.lexists(os.path.join(provided, name))}: + mirror(path, provided, name, os.path.join(tmp, top, entry)) + else: + mirror(source, None, entry, os.path.join(tmp, top)) + write_if_changed(os.path.join(tmp, MARKER), stamp) + old = "%s.%d.old" % (rootfs, os.getpid()) + if os.path.lexists(rootfs): + os.rename(rootfs, old) + os.rename(tmp, rootfs) + shutil.rmtree(old, ignore_errors=True) + return True + + def host_preloads(): listed = read_text(HOST_PRELOAD) or "" return [name for name in PRELOAD_NAMES if name in listed] @@ -247,10 +326,14 @@ def install_preloads(root): if os.path.isfile(source): copy_if_changed(source, os.path.join(root, libdir, "droiddeck", name)) shipped.setdefault(name, set()).add(arch) - for name in (THUNK_AUDIT, VULKAN_PIN): - source = os.path.join(PRELOADS, "x86_64", name) - if os.path.isfile(source): - copy_if_changed(source, os.path.join(root, "lib/x86_64-linux-gnu/droiddeck", name)) + pin = os.path.join(PRELOADS, "x86_64", VULKAN_PIN) + if os.path.isfile(pin): + copy_if_changed(pin, os.path.join(root, VULKAN_PIN_DIR, "libvulkan.so.1")) + alias = os.path.join(root, VULKAN_PIN_DIR, "libvulkan.so") + if not os.path.islink(alias) or os.readlink(alias) != "libvulkan.so.1": + if os.path.lexists(alias): + os.unlink(alias) + os.symlink("libvulkan.so.1", alias) wanted = [name for name in host_preloads() if name in shipped] if len(shipped.get(FAULT_REPORT, ())) == len(GUEST_LIBDIRS): wanted.append(FAULT_REPORT) @@ -270,14 +353,16 @@ def write_config(fex, root): def link_steam_sdk(): for sdk, candidates in (("sdk64", ("linux64", "ubuntu12_64")), ("sdk32", ("linux32", "ubuntu12_32"))): link = os.path.join(HOME, ".steam", sdk) - if os.path.lexists(link): - continue want = "x86_64" if sdk == "sdk64" else "i386" + if elf_arch(os.path.join(link, "steamclient.so")) == want: + continue for candidate in candidates: directory = os.path.join(STEAM_ROOT, candidate) if elf_arch(os.path.join(directory, "steamclient.so")) == want: os.makedirs(os.path.dirname(link), exist_ok=True) - os.symlink(directory, link) + tmp = "%s.%d.tmp" % (link, os.getpid()) + os.symlink(directory, tmp) + os.replace(tmp, link) break @@ -308,7 +393,7 @@ def request_install(): return [] -def describe(fex, platform): +def describe(fex, platform, graphics=None): return { "fex": fex["bin"] if fex else None, "server": fex["server"] if fex else None, @@ -317,6 +402,7 @@ def describe(fex, platform): "steamclient64": os.path.realpath(os.path.join(HOME, ".steam", "sdk64", "steamclient.so")) if elf_arch(os.path.join(HOME, ".steam", "sdk64", "steamclient.so")) == "x86_64" else None, "ready": bool(fex and fex["server"] and platform), + "graphics": graphics, } @@ -346,13 +432,27 @@ def prepare(): if materialize(platform): say("prepared %s as the x86 runtime" % os.path.basename(platform)) install_preloads(root) + provider = graphics_platform() + if provider and materialize(provider): + say("prepared %s for the x86 runtime's C and C++ libraries" % os.path.basename(provider)) + if not provider: + say("Steam Linux Runtime 4.0 (Steam app %s) is not installed yet; x86 games may not find their graphics drivers" + % SLR4_APPID) + elif not provides_newer(platform, provider): + say("%s has no newer C and C++ libraries than %s" % (os.path.basename(provider), os.path.basename(platform))) + provider = None + else: + if build_rootfs(platform, provider): + say("built the x86 runtime from %s with the C and C++ libraries of %s" + % (os.path.basename(platform), os.path.basename(provider))) + root = os.path.join(STATE, "rootfs") write_config(fex, root) fex["rootfs"] = root try: link_steam_sdk() except OSError: pass - status = describe(fex, platform) + status = describe(fex, platform, provider) write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n") with contextlib.suppress(OSError): os.unlink(WANTED) @@ -430,6 +530,8 @@ def guest_environment(fex, env): result["STEAM_COMPAT_DATA_PATH"] = short result.setdefault("FEX_SILENTLOG", "0") result.setdefault("FEX_OUTPUTLOG", "stderr") + # Mono's incremental Boehm collector corrupts its heap under FEX, so Unity games crash at their first collections. + result.setdefault("GC_DISABLE_INCREMENTAL", "1") if fex["portable"]: result["FEX_PORTABLE"] = "1" else: @@ -445,7 +547,7 @@ def guest_environment(fex, env): result["FEX_THUNKCONFIG"] = os.path.join(CONFIG_DIR, "ThunksConfig.json") preload = [part for part in split_paths(result.get("LD_PRELOAD")) if os.path.exists(part) and not is_arm(part)] library_path = [part for part in (result.get("LD_LIBRARY_PATH") or "").split(":") - if part and "steamrtarm64" not in part and "aarch64" not in part] + if part and "arm64" not in part and "aarch64" not in part] for name, parts in (("LD_PRELOAD", preload), ("LD_LIBRARY_PATH", library_path)): if parts: result[name] = ":".join(parts) @@ -483,6 +585,7 @@ def vulkan_thunk_loads(fex, folder): needed = version_names(os.path.join(fex["guest_thunks"], VULKAN_THUNK)) if not needed: return False + needed |= version_names(os.path.join(PRELOADS, "x86_64", VULKAN_PIN)) found = bundled_libraries(folder) for name, prefix in RUNTIME_LIBRARIES: library = found.get(name) or os.path.join(fex["rootfs"], "lib/x86_64-linux-gnu", name) @@ -509,9 +612,10 @@ def launch(command, env, mode, decide=None): x86_64 = elf_arch(program) != "i386" thunks = "on" if "FEX_THUNKCONFIG" in guest else "off" folder = decide if decide and os.path.isdir(decide) else os.path.dirname(program) - if thunks == "on" and x86_64 and all(os.path.isfile(os.path.join(PRELOADS, "x86_64", name)) for name in (THUNK_AUDIT, VULKAN_PIN)) \ + if thunks == "on" and x86_64 and os.path.isfile(os.path.join(PRELOADS, "x86_64", VULKAN_PIN)) \ and vulkan_thunk_loads(fex, folder): - guest["LD_AUDIT"] = ":".join([THUNK_AUDIT_GUEST] + split_paths(guest.get("LD_AUDIT"))) + # Any LD_AUDIT module makes Mono's garbage collector crash under FEX, so the Vulkan thunk is pinned by search path. + guest["LD_LIBRARY_PATH"] = ":".join(["/usr/" + VULKAN_PIN_DIR] + split_paths(guest.get("LD_LIBRARY_PATH"))) thunks = "on, its own Vulkan loader too" say("running %s with %s (runtime %s, thunks %s)" % (program, fex["bin"], guest.get("FEX_ROOTFS", "none"), thunks)) return os.execve(fex["bin"], [fex["bin"], program] + command[1:], guest) @@ -563,7 +667,7 @@ def extracted(): def want_fex(): with locked(): - status = describe(fex_install(), runtime_platform()) + status = describe(fex_install(), runtime_platform(), graphics_platform()) if not status["ready"]: request_install() write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n") @@ -679,7 +783,7 @@ def main(argv): return 0 if prepare() else 1 if action == "status": with locked(): - status = describe(fex_install(), runtime_platform()) + status = describe(fex_install(), runtime_platform(), graphics_platform()) write_if_changed(STATUS_FILE, json.dumps(status, indent=2) + "\n") print(json.dumps(status, indent=2)) return 0 if status["ready"] else 1 diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat index 3cb4c9cf32..c9c8cb1c2a 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat @@ -126,6 +126,29 @@ INSTALL_JS = r""" return "installed"; })() """.replace("__BINDING__", BINDING) +TOOLS_JS = r""" +(() => { + if (window.__droiddeckTools) return "present"; + const installs = SteamClient.Installs, downloads = SteamClient.Downloads; + if (typeof installs?.OpenInstallWizard !== "function" || typeof installs?.RegisterForShowInstallWizard !== "function" || + typeof installs?.ContinueInstall !== "function" || typeof downloads?.QueueAppUpdate !== "function") + throw new Error("the client's install calls are not ready"); + const self = { asked: new Map() }; + installs.RegisterForShowInstallWizard((state) => { + const app = Number(state?.currentAppID); + if (state?.eInstallState === 7 && Date.now() - (self.asked.get(app) || 0) < 120000) { + self.asked.delete(app); + installs.ContinueInstall(); + } + }); + self.install = (app) => { self.asked.set(app, Date.now()); installs.OpenInstallWizard([app], "0"); return true; }; + self.update = (app) => { downloads.QueueAppUpdate(app, "0"); return true; }; + window.__droiddeckTools = self; + return "installed"; +})() +""" +TOOL_CHECK_SECONDS = 60 +TOOL_RETRY_SECONDS = 300 SWITCH_BINDING = "droiddeckSwitchToDesktop" SWITCH_JS = r""" (() => { @@ -185,7 +208,7 @@ VR_JS = r""" return; } const overview = window.appStore?.GetAppOverviewByGameID?.(gameid); - const vr = overview?.vr_only || overview?.vr_supported || overview?.BSupportsVR?.(); + const vr = overview?.vr_only === true; if (vr && self.subscription && /^[1-9][0-9]{0,19}$/.test(gameid)) { if (self.pending.has(gameid)) return; self.lastError = null; @@ -397,6 +420,9 @@ class Page: raise RuntimeError((details.get("exception") or {}).get("description") or details.get("text") or "script failed") return result.get("result", {}).get("value") + def tools(self, call): + return self.evaluate("%s;\nwindow.__droiddeckTools.%s" % (TOOLS_JS, call)) + def compat(self, call): return self.evaluate("%s;\nwindow.__droiddeckCompat.%s" % (INSTALL_JS, call)) @@ -481,6 +507,8 @@ class Helper: self.known = set() self.installed = None self.fex_asked = set() + self.tools_asked = {} + self.tools_checked = None self.vr_launch = None def attach(self): @@ -524,7 +552,8 @@ class Helper: prior_auto = state.get("auto", {}) if not isinstance(prior_auto, dict): prior_auto = {} - prior_native = state.get("native", ()) + # "native" from earlier builds also lists dual-platform games nobody chose to run natively. + prior_native = state.get("native_choices", ()) native_choices = set(prior_native if isinstance(prior_native, (list, tuple, set)) else ()) apps = sorted(set(installed) | set(picks) | set(prior_auto) | native_choices, key=COMPAT["app_order"]) overrides = COMPAT["requested_games"]( @@ -538,12 +567,19 @@ class Helper: if raw_mapping is None: for app in native_choices: current[app] = "" + for app in set(native) - native_choices: + if not current.get(app): + current.pop(app, None) else: for app in set(native) | native_choices: if app in raw_mapping: - current[app] = raw_mapping[app] + # The client shows an explicit native choice as the tool it inherits, and writes config.vdf late. + if raw_mapping[app] == "" or current.get(app) not in self.known: + current[app] = raw_mapping[app] elif app in prior_auto or app in native_choices: current[app] = "" + elif not current.get(app): + current.pop(app, None) changes, auto = COMPAT["plan_mapping"]( current, installed, [t["name"] for t in live], default, COMPAT["followers"](state, current), native, picks, overrides, @@ -554,18 +590,36 @@ class Helper: tool if tool is not None else "Steam native default")) state.update( auto={app: tool for app, tool in auto.items() if tool is not COMPAT["NATIVE_CHOICE"]}, - native=sorted(app for app, tool in auto.items() if tool is COMPAT["NATIVE_CHOICE"]), + native_choices=sorted(app for app, tool in auto.items() if tool is COMPAT["NATIVE_CHOICE"]), tools=catalog, live=True) + state.pop("native", None) if waiting: state["pending"] = wanted say("%s is new to the running client; it applies when Steam next starts" % wanted) else: state.pop("pending", None) COMPAT["write_json"](state_file, state) - if (any(app in installed and tool == COMPAT["FEX_TOOL"] for app, tool in native.items()) or - os.path.exists(COMPAT["fex_wanted_marker"]())): - for app in COMPAT["request_fex"](self.steam_root, self.fex_asked): - say("asked the client to install %s for x86 Linux titles and programs" % app) + + def ensure_tools(self): + """Proton, FEX and the runtimes FEX needs are fetched as soon as the client is up, never left pending.""" + now = time.monotonic() + if self.tools_checked is not None and now - self.tools_checked < TOOL_CHECK_SECONDS: + return + self.tools_checked = now + if COMPAT["game_running"](): + return + for app, action in COMPAT["tool_downloads"](self.steam_root): + if now - self.tools_asked.get(app, -TOOL_RETRY_SECONDS) < TOOL_RETRY_SECONDS: + continue + self.tools_asked[app] = now + try: + self.page.tools("%s(%d)" % (action, int(app))) + say("asked the client to %s %s" % (action, app)) + except Exception as e: + say("the client could not %s %s (%s)" % (action, app, e)) + if action == "install": + for asked in COMPAT["request_fex"](self.steam_root, self.fex_asked): + say("asked the client to install %s through steam://install" % asked) def request_waiting(self): request = COMPAT["read_json"](COMPAT["state_path"]("request.json")) @@ -592,6 +646,7 @@ class Helper: f.write("%d\n" % os.getpid()) say("attached to the client on port %d" % self.port) self.reconcile() + self.ensure_tools() while True: sources = [self.page.ws] + ([watcher] if watcher.fileno() >= 0 else []) ready = [self.page.ws] if self.page.ws.pending() else select.select(sources, [], [], 30 if watcher.fileno() >= 0 else 2)[0] @@ -606,6 +661,7 @@ class Helper: watcher.changed() self.drain() self.reconcile() + self.ensure_tools() def detach(): diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install index 7e9b4e0738..3ce263c0d7 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-install @@ -111,7 +111,8 @@ mkdir -p "$HOME/.steam" ln -sfn "$steam_root" "$HOME/.steam/root" ln -sfn "$steam_root" "$HOME/.steam/steam" ln -sfn "$steam_root/steamrtarm64" "$HOME/.steam/bin64" -ln -sfn "$steam_root/linuxarm64" "$HOME/.steam/sdk64" +# sdk64 is where x86_64 Steamworks looks for steamclient.so; arm64 builds look in sdkarm64. +ln -sfn "$steam_root/linux64" "$HOME/.steam/sdk64" ln -sfn "$steam_root/linuxarm64" "$HOME/.steam/sdkarm64" ln -sfn "$steam_root/steamrtarm64" "$HOME/.steam/binarm64" ln -sfn "$steam_root/linux32" "$HOME/.steam/sdk32" diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 index 4a2113fbf4..2c27c9db4d 100755 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-x64 @@ -319,24 +319,101 @@ print("droiddeck-steam-x64: %d Linux title(s) on DroidDeck direct (%d on the new PY } -x64_prepare() { -if [ ! -x /usr/local/bin/FEX ] || [ "$(cat /usr/local/share/fex-emu/.droiddeck-tag 2>/dev/null)" != "$FEX_TAG" ]; then - step "downloading FEX ($FEX_TAG)" +# Whether every program in the FEX tree at $1 finds its libraries (r4 did not without libxxhash). +fex_loads() { + local b out + for b in FEX FEXServer unsquashfs; do + out=$(/usr/lib/ld-linux-aarch64.so.1 --list "$1/usr/local/bin/$b" 2>&1) && ! grep -q "not found" <<<"$out" && continue + echo "== FEX check: $b: $(grep -E "not found|error" <<<"$out" | tr -s '\t ' ' ' | tr '\n' ';')" >&2 + return 1 + done +} + +# Installs one FEX build only once its archive matches the sha256 and it loads. The files it replaces are kept +# until the installed copy loads too, and put back otherwise; the tag is written last. +fex_install() { + local tag=$1 sha=$2 urls=$3 dst=/ tmp u f tmp=$(mktemp -d) - curl -fL --progress-bar "$FEX_URL" -o "$tmp/fex.tzst" - if [ "$FEX_SHA256" != PENDING ]; then echo "$FEX_SHA256 $tmp/fex.tzst" | sha256sum -c --quiet; fi - zstd -dc "$tmp/fex.tzst" | tar -C / -x + for u in $urls; do + curl -fsSL --retry 2 "$u" -o "$tmp/fex.tzst" && echo "$sha $tmp/fex.tzst" | sha256sum -c --quiet >/dev/null 2>&1 && break + rm -f "$tmp/fex.tzst" + done + if [ ! -s "$tmp/fex.tzst" ]; then + echo "== FEX $tag: no source gave the archive with sha256 ${sha:0:12}" >&2 + rm -rf "$tmp" + return 1 + fi + if ! { mkdir "$tmp/root" && zstd -dc "$tmp/fex.tzst" | tar -C "$tmp/root" -x && fex_loads "$tmp/root"; }; then + rm -rf "$tmp" + return 1 + fi + (cd "$tmp/root" && find . ! -type d) > "$tmp/files" + mkdir "$tmp/old" + while IFS= read -r f; do + f=${f#./} + if [ -e "$dst$f" ] || [ -L "$dst$f" ]; then + cp -a --parents "$dst$f" "$tmp/old" || { echo "== FEX $tag: could not keep $dst$f aside" >&2; rm -rf "$tmp"; return 1; } + fi + done < "$tmp/files" + if tar -C "$tmp/root" -c . | tar -C "$dst" -x && fex_loads "$dst" && + mkdir -p "${dst}usr/local/share/fex-emu" && echo "$tag" > "${dst}usr/local/share/fex-emu/.droiddeck-tag"; then + rm -rf "$tmp" + return 0 + fi + echo "== FEX $tag: the installed copy did not load or its tag was not written; putting the previous files back" >&2 + while IFS= read -r f; do + f=${f#./} + [ -e "$tmp/old/$dst$f" ] || [ -L "$tmp/old/$dst$f" ] || rm -f "$dst$f" + done < "$tmp/files" + tar -C "$tmp/old$dst" -c . | tar -C "$dst" -x || echo "== FEX $tag: could not put the previous files back" >&2 rm -rf "$tmp" - mkdir -p /usr/local/share/fex-emu && echo "$FEX_TAG" > /usr/local/share/fex-emu/.droiddeck-tag -fi -step "FEX ready ($FEX_TAG)" + return 1 +} + +# The build DroidDeck-Components' fex.json names (the app passes it as BL_FEX_*) comes first, then a working +# installed one, then FEX_TAG above. Sets FEX_NOW and FEX_FROM. +x64_fex() { + local have ok= + have=$(cat /usr/local/share/fex-emu/.droiddeck-tag 2>/dev/null || true) + [ -x /usr/local/bin/FEX ] && fex_loads / && ok=1 + if [ -n "${BL_FEX_TAG:-}" ]; then + if [ -n "$ok" ] && [ "$have" = "$BL_FEX_TAG" ]; then FEX_NOW=$have FEX_FROM=catalog; return 0; fi + step "downloading FEX ($BL_FEX_TAG)" + if fex_install "$BL_FEX_TAG" "${BL_FEX_SHA256:-}" "${BL_FEX_URLS:-}"; then FEX_NOW=$BL_FEX_TAG FEX_FROM=catalog; return 0; fi + if [ -n "$ok" ]; then FEX_NOW=$have FEX_FROM="kept; $BL_FEX_TAG did not install"; return 0; fi + fi + if [ -n "$ok" ] && [ "$have" = "$FEX_TAG" ]; then FEX_NOW=$have FEX_FROM=built-in; return 0; fi + step "downloading FEX ($FEX_TAG)" + if fex_install "$FEX_TAG" "$FEX_SHA256" "$FEX_URL"; then FEX_NOW=$FEX_TAG FEX_FROM=built-in; return 0; fi + if [ -n "$ok" ]; then FEX_NOW=$have FEX_FROM="kept; $FEX_TAG did not install"; return 0; fi + return 1 +} + +# A resumable download that reports every tenth of its size as a step. +x64_fetch() { + local url=$1 out=$2 label=$3 total pid rc=0 last=-1 pct + total=$(curl -fsSIL "$url" 2>/dev/null | tr -d '\r' | awk 'tolower($1) == "content-length:" { v = $2 } END { print v + 0 }') + curl -fL -sS -C - "$url" -o "$out" & + pid=$! + while kill -0 "$pid" 2>/dev/null; do + sleep 3 + [ "$total" -gt 0 ] || continue + pct=$(( $(stat -c %s "$out" 2>/dev/null || echo 0) * 10 / total * 10 )) + if [ "$pct" -gt "$last" ]; then last=$pct; step "$label ($pct%)"; fi + done + wait "$pid" || rc=$? + return "$rc" +} + +x64_prepare() { +x64_fex || { step "FEX could not be installed; see $LOG"; exit 1; } +step "FEX ready ($FEX_NOW, $FEX_FROM)" # The client's opt-in to its SteamRT3 build; without it, it re-executes through steam.sh, whose checks fail under proot. mkdir -p "$STEAM_X64" && : > "$STEAM_X64/.steam-enable-steamrt64-client" if [ ! -f "$ROOTFS/.droiddeck-complete" ]; then - step "downloading FEX's Ubuntu 24.04 x86 rootfs" # Resumes a part-done download; a finished one answers 416, which is not a failure here. - curl -fL --progress-bar -C - "$ROOTFS_URL" -o "$X64_HOME/rootfs.sqsh" || { + x64_fetch "$ROOTFS_URL" "$X64_HOME/rootfs.sqsh" "downloading FEX's Ubuntu 24.04 x86 rootfs" || { rc=$? [ "$rc" = 22 ] && [ -s "$X64_HOME/rootfs.sqsh" ] || { step "rootfs download failed (curl $rc)"; exit 1; } } @@ -350,6 +427,7 @@ if [ ! -f "$ROOTFS/.droiddeck-complete" ]; then rm -f "$X64_HOME/rootfs.sqsh" touch "$ROOTFS/.droiddeck-complete" fi +echo "== x86-64 rootfs: $(sed -n 's|.*/download/\([^/]*\)/.*|\1|p' <<<"$ROOTFS_URL") (sha256 ${ROOTFS_SHA256:0:12})" >&2 # FEX falls back to the guest's own /etc/ld.so.preload (arm64 libraries) when the rootfs has none. The x86 # session shim provides System V IPC, which Android kernels lack and the client's tier0 needs to start. : > "$ROOTFS/etc/ld.so.preload" @@ -792,6 +870,37 @@ export STEAM_STEAMRT_RECURSION_GUARD=1 export BL_WEBHELPER_HIDE_TRACER=1 } +x64_manifest_version() { + local chan + chan=$(cat "$STEAM_X64/package/beta" 2>/dev/null || echo "$X64_CHANNEL") + awk -F'"' '$2 == "version" { print $4; exit }' "$STEAM_X64/package/steam_client_${chan}_$1.manifest" 2>/dev/null || echo "?" +} + +# What x86 GL and Vulkan look like through FEX's thunks, for a session whose menus failed on the GPU. +x64_gpu_probe() { + local fex=${BL_FEX:-/usr/local/bin/FEX} + echo "== x86-64 GPU probe (x86 glxinfo and vulkaninfo through FEX):" + ( + unset LD_LIBRARY_PATH + export DISABLE_GAMESCOPE_WSI=1 vk_xwayland_wait_ready=true LIBGL_KOPPER_DISABLE=true + timeout 30 "$fex" /usr/bin/glxinfo -B 2>&1 | grep -E "OpenGL (renderer|core profile version|version) string|direct rendering|rror" | head -5 + timeout 30 "$fex" /usr/bin/vulkaninfo --summary 2>&1 | grep -E "deviceName|driverName|driverInfo|apiVersion|rror" | head -6 + ) | sed 's/^/ /' +} + +# Steam's menus come from the web helper; when its GPU process keeps exiting, Chromium gives up on the GPU and +# the menus never appear. Says so once in the session log, with the probe above. +x64_gpu_watch() { + local log=$STEAM_X64/logs/console-linux.txt from n codes + from=$(( $(wc -l 2>/dev/null < "$log" || echo 0) + 1 )) + tail -n0 -F --pid=$$ "$log" 2>/dev/null | grep -q -m1 "GPU process isn't usable" || return 0 + n=$(tail -n +"$from" "$log" | grep -c "GPU process exited unexpectedly" || true) + codes=$(tail -n +"$from" "$log" | grep -oE "GPU process exited unexpectedly: exit_code=[0-9]+" | sed 's/.*=//' | + sort | uniq -c | awk '{ printf "%s%s x%s", s, $2, $1; s = ", " }') + echo "== x86-64: Steam's menu renderer gave up on the GPU after $n GPU process exits (exit code ${codes:-?}); the menus stay blank. See steam/console-linux.txt and steam/webhelper_gpu.txt" + x64_gpu_probe +} + x64_exec() { x64_env cd "$STEAM_X64" @@ -828,6 +937,8 @@ x64_exec() { touch "$STEAM_X64/logs/bootstrap_log.txt" ( tail -n0 -F --pid=$$ "$STEAM_X64/logs/bootstrap_log.txt" 2>/dev/null | grep --line-buffered -oE 'Downloading update \([0-9,]+ of [0-9,]+ KB\)' | sed -u 's/,//g' >&2 ) & + echo "== x86-64 client: ubuntu12 $(x64_manifest_version ubuntu12), steamrt64 $(x64_manifest_version steamrt64) (the client may update itself)" >&2 + x64_webhelper_gpu && { x64_gpu_watch >&2 & } exec "${BL_FEX:-/usr/local/bin/FEX}" "$STEAM_X64/steamrt64/steam" "$@" } diff --git a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steamvr b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steamvr old mode 100644 new mode 100755 index 8facf7ddf4..242bd169e1 --- a/tools/linuxfs/overlay/usr/local/bin/droiddeck-steamvr +++ b/tools/linuxfs/overlay/usr/local/bin/droiddeck-steamvr @@ -23,6 +23,24 @@ quest_settings() { "$HOME/.local/share/Steam/config/steamvr.vrsettings" "$backup" } +configure_graphics() { + case "$(cat /sys/class/kgsl/kgsl-3d0/gpu_model 2>/dev/null)" in + Adreno840*) + # The session's forced sysmem mode loses the Vulkan device in SteamVR. + export TU_DEBUG="$( + IFS=', ' + set -f + separator= + for flag in ${TU_DEBUG:-}; do + case "$flag" in ''|sysmem) continue ;; esac + printf '%s%s' "$separator" "$flag" + separator=, + done + )" + ;; + esac +} + stop() { rm -f "$state/active" for n in vrcompositor vrserver vrmonitor vrdashboard vrstartup vrwebhelper; do @@ -176,6 +194,8 @@ JSON export VK_LAYER_PATH="$layer${VK_LAYER_PATH:+:$VK_LAYER_PATH}" export VK_INSTANCE_LAYERS="VK_LAYER_DROIDDECK_vr${VK_INSTANCE_LAYERS:+:$VK_INSTANCE_LAYERS}" export VK_LOADER_LAYERS_DISABLE="${VK_LOADER_LAYERS_DISABLE:-~implicit~}" + configure_graphics + export LD_PRELOAD="$layer/libdroiddeck_vr_scheduling.so${LD_PRELOAD:+:$LD_PRELOAD}" if [ "${DROIDDECK_VR_PRESENT:-}" = questwsi ]; then quest_settings apply || exit 1 startup_handed_off=0 diff --git a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility index e1ce3adebe..cc68575e54 100755 --- a/tools/linuxfs/overlay/usr/local/bin/steam-compatibility +++ b/tools/linuxfs/overlay/usr/local/bin/steam-compatibility @@ -21,7 +21,11 @@ FEX_LAUNCHER = "droiddeck-fex-tool" FEX_FILES = ("toolmanifest.vdf", "compatibilitytool.vdf", FEX_LAUNCHER) FEX_APPID = "3127680" SNIPER_APPID = "1628350" -FEX_DEPENDENCIES = (FEX_APPID, SNIPER_APPID) +SLR4_APPID = "4183110" +FEX_DEPENDENCIES = (FEX_APPID, SNIPER_APPID, SLR4_APPID) +REQUIRED_TOOLS = (PROTON_ARM64_APPID,) + FEX_DEPENDENCIES +FULLY_INSTALLED = 4 +UPDATE_REQUIRED = 2 REQUEST_HANDOFF_SECONDS = 30 PLAYABLE_TYPES = frozenset(("game", "demo", "application", "beta")) COMPAT_DIR = os.path.join(os.environ.get("HOME", "/root"), ".local", "share", "droiddeck-compat") @@ -850,6 +854,36 @@ def native_targets(steam_root, apps): return targets +def app_manifest(steam_root, app): + for library in libraries(steam_root): + try: + with open(os.path.join(library, "steamapps", "appmanifest_%s.acf" % app), encoding="utf-8", errors="replace") as f: + return tokenize(f.read()) + except OSError: + continue + return None + + +def manifest_flags(tokens): + for i in range(len(tokens) - 1): + if tokens[i].lower() == '"stateflags"': + value = tokens[i + 1].strip('"') + return int(value) if value.isdigit() else 0 + return 0 + + +def tool_downloads(steam_root): + """(app, "install" or "update") for each tool the client has yet to install or bring up to date.""" + wanted = [] + for app in REQUIRED_TOOLS: + tokens = app_manifest(steam_root, app) + if tokens is None: + wanted.append((app, "install")) + elif not manifest_flags(tokens) & FULLY_INSTALLED or manifest_flags(tokens) & UPDATE_REQUIRED: + wanted.append((app, "update")) + return wanted + + def fex_missing(steam_root): missing = [] for app in FEX_DEPENDENCIES: @@ -1174,6 +1208,21 @@ def steam_running(): return False +def game_running(): + try: + pids = [p for p in os.listdir("/proc") if p.isdigit()] + except OSError: + return False + for pid in pids: + try: + with open("/proc/%s/cmdline" % pid, "rb") as f: + if b"\0SteamLaunch\0AppId=" in f.read(): + return True + except OSError: + continue + return False + + def live_helper_running(directory=None): try: with open(state_path("live.pid", directory)) as f: @@ -1209,21 +1258,22 @@ def register_default(config_path, apps=(), protect=(), default=None, catalog=Non default = state.get("default") if state.get("default") in names else TOOL steam_root = os.path.dirname(os.path.dirname(os.path.abspath(config_path))) overrides = requested_games(game_requests(directory), catalog) - native = native_targets(steam_root, set(apps) | set(picks)) + managed = state.get("auto", {}).keys() if isinstance(state.get("auto"), dict) else () + native_choices = state.get("native_choices", ()) + native = native_targets(steam_root, set(apps) | set(picks) | set(managed) | set(native_choices)) if linux_tool != FEX_TOOL: native = {app: linux_tool if tool == FEX_TOOL else tool for app, tool in native.items()} changes, auto = plan_mapping( - current, apps, names, default, followers(state, current), - native, picks, - overrides, state.get("auto", {}).keys() if isinstance(state.get("auto"), dict) else (), - state.get("native", ())) + current, apps, names, default, followers(state, current), native, picks, + overrides, managed, native_choices) for app, tool in changes.items(): set_mapping(tokens, mapping, app, tool) text = serialize(tokens) if text != serialize(tokenize(original)): write_changed(config_path, text) state["auto"] = {app: tool for app, tool in auto.items() if tool is not NATIVE_CHOICE} - state["native"] = sorted(app for app, tool in auto.items() if tool is NATIVE_CHOICE) + state["native_choices"] = sorted(app for app, tool in auto.items() if tool is NATIVE_CHOICE) + state.pop("native", None) state["tools"] = catalog state.setdefault("default", default) write_json(state_path("state.json", directory), state) diff --git a/tools/prepare_windows_runtime.py b/tools/prepare_windows_runtime.py index 8329c032c8..831fc7d7de 100644 --- a/tools/prepare_windows_runtime.py +++ b/tools/prepare_windows_runtime.py @@ -42,7 +42,15 @@ LOCAL_BUILD_PLUMBING = {'app/build.gradle', 'tools/release/runtime_inputs.py'} LOCAL_ANDROID_SOURCES = {'app/src/main/cpp/CMakeLists.txt', 'app/src/main/cpp/viture/sdk_bridge.cpp', 'app/src/main/cpp/viture/display_modes.h', - 'app/src/main/cpp/waylandcomp/src/cardboard.c'} + 'app/src/main/cpp/viture/stereo_frame_gate.h', + 'app/src/main/cpp/viture/uvc_bridge.cpp', + 'app/src/main/cpp/waylandcomp/src/cardboard.c', + 'app/src/main/cpp/waylandcomp/src/cardboard.h', + 'app/src/main/cpp/waylandcomp/src/cardboard.frag', + 'app/src/main/cpp/waylandcomp/src/cardboard_frag.h', + 'app/src/main/cpp/waylandcomp/src/waylandcomp_jni.c', + 'app/src/main/cpp/waylandcomp/src/spatialpose.c', + 'app/src/main/cpp/waylandcomp/CMakeLists.txt'} # These audited helper updates are copied from this checkout by runtime.record(). # Permit them only while source_assets() still guarantees that staging path. LOCAL_SESSION_HELPERS = {'tools/linuxfs/overlay/usr/local/bin/droiddeck-steam-compat', diff --git a/tools/release/runtime_inputs.py b/tools/release/runtime_inputs.py index 09c80f0af6..a539e46c4e 100644 --- a/tools/release/runtime_inputs.py +++ b/tools/release/runtime_inputs.py @@ -19,6 +19,7 @@ SOURCE_PATHS = ['app/build.gradle', 'app/src/main/cpp/fakeinput_steam.cpp', 'app 'tools/release/runtime_inputs.py', 'app/src/main/assets/desktop-removal', 'tools/quest', 'tools/vr/src', 'tools/vr/driver_droiddeck', 'tools/vr/layer', 'tools/vr/build.sh', 'app/src/main/cpp/waylandcomp/src/headpose_shm.h', + 'app/src/main/cpp/waylandcomp/src/spatialpose_shm.h', 'app/src/main/cpp/adrenotools/src/hook/kgsl.h', 'app/src/main/assets/graphics_driver/adrenotools-turnip25.1.0.tzst'] @@ -70,14 +71,16 @@ def required(): for arch in ['x86_64', 'i386']: paths += ['assets/linuxfs/' + arch + '/' + lib for lib in ['libfakeinput.so', 'libblsession.so']] paths += ['assets/linuxfs/x86_64/' + lib for lib in - ['libfaultreport.so', 'libthunkaudit.so', 'libvulkan-thunk.so', 'libwebkitinput.so']] + ['libfaultreport.so', 'libvulkan-thunk.so', 'libwebkitinput.so']] paths += ['assets/linuxfs/i386/libfaultreport.so'] paths += ['assets/linuxfs/usr/local/lib/droiddeck-msitools/' + name for name in ['msiinfo', 'cabextract', '7z', '7z.so', 'libmsi-1.0.so.0', 'libgsf-1.so.114', 'libgcab-1.0.so.0']] paths += ['assets/linuxfs/usr/local/lib/droiddeck-vr/' + name for name in - ['droiddeck/bin/linuxarm64/driver_droiddeck.so', 'droiddeck/driver.vrdrivermanifest', + ['droiddeck/bin/linuxarm64/driver_droiddeck.so', 'droiddeck/bin/linuxarm64/xr-display-mode', + 'droiddeck/driver.vrdrivermanifest', 'droiddeck/resources/settings/default.vrsettings', 'layer/libVkLayer_droiddeck_vr.so', - 'layer/VK_LAYER_DROIDDECK_vr.json', 'layer/VK_LAYER_DROIDDECK_vr_implicit.json']] + 'layer/VK_LAYER_DROIDDECK_vr.json', 'layer/VK_LAYER_DROIDDECK_vr_implicit.json', + 'layer/libdroiddeck_vr_scheduling.so']] for side in ['left', 'right']: paths += [f'assets/linuxfs/usr/local/lib/droiddeck-vr/droiddeck/resources/rendermodels/droiddeck_hand_{side}/{name}' for name in [f'droiddeck_hand_{side}.json', 'hand.mtl', 'hand.png', 'hand_open.obj', 'hand_fist.obj', diff --git a/tools/tests/steam_vr_launch_harness.js b/tools/tests/steam_vr_launch_harness.js index ef9c4d5b62..62d0127398 100644 --- a/tools/tests/steam_vr_launch_harness.js +++ b/tools/tests/steam_vr_launch_harness.js @@ -34,24 +34,26 @@ assert.strictEqual(calls[0].receiver, apps); const receiver = {}; apps.RunGame.call(receiver, '611670', 'custom args', 2, 100); apps.RunGame('611670', 'duplicate', -1, 100); -apps.RunGame(620980, '', -1, 100); -assert.deepStrictEqual(requests, ['611670', '620980']); -assert.strictEqual(calls.length, 1); +assert.strictEqual(apps.RunGame(620980, '', -1, 100), 'native'); +assert.deepStrictEqual(requests, ['611670']); +assert.strictEqual(calls.length, 2); +assert.deepStrictEqual(calls[1].args, [620980, '', -1, 100]); changed(false); -assert.strictEqual(calls.length, 1); +assert.strictEqual(calls.length, 2); changed(true); assert.strictEqual(calls.length, 3); -assert.strictEqual(calls[1].receiver, receiver); -assert.deepStrictEqual(calls[1].args, ['611670', 'custom args', 2, 100]); -assert.deepStrictEqual(calls[2].args, [620980, '', -1, 100]); +assert.strictEqual(calls[2].receiver, receiver); +assert.deepStrictEqual(calls[2].args, ['611670', 'custom args', 2, 100]); assert.strictEqual(timers.size, 0); changed(true); assert.strictEqual(calls.length, 3); -apps.RunGame('18446744069414584320', '', -1, 100); +changed(false); +assert.strictEqual(apps.RunGame('18446744069414584320', '', -1, 100), 'native'); assert.deepStrictEqual(calls[3].args, ['18446744069414584320', '', -1, 100]); -assert.strictEqual(requests.at(-1), '18446744069414584320'); +assert.deepStrictEqual(requests, ['611670']); assert.strictEqual(timers.size, 0); +changed(true); apps.RunGame('250820', '', -1, 100); openvr.StartVR(true); diff --git a/tools/tests/test_build_hand_lite.py b/tools/tests/test_build_hand_lite.py new file mode 100644 index 0000000000..ac9e376bad --- /dev/null +++ b/tools/tests/test_build_hand_lite.py @@ -0,0 +1,35 @@ +import importlib.util +import io +from pathlib import Path +import unittest +import zipfile + + +spec = importlib.util.spec_from_file_location('build_hand_lite', Path(__file__).parents[1] / 'build_hand_lite.py') +builder = importlib.util.module_from_spec(spec) +spec.loader.exec_module(builder) + + +class HandLiteBundleTest(unittest.TestCase): + def test_embedded_labels_are_reproducible_without_changing_model_bytes(self): + model = b'\x08\x00\x00\x00TFL3model tensors and weights' + outputs = [] + for year, order in [(2020, ['labels.txt', 'handedness.txt']), + (2026, ['handedness.txt', 'labels.txt'])]: + source = io.BytesIO(model) + with zipfile.ZipFile(source, 'a') as archive: + for name in order: + entry = zipfile.ZipInfo(name, (year, 10, 16, 12, 30, 0)) + archive.writestr(entry, name.encode()) + output = builder.canonicalize_associated_files(source.getvalue()) + self.assertEqual(model, output[:len(model)]) + self.assertEqual(output, builder.canonicalize_associated_files(output)) + with zipfile.ZipFile(io.BytesIO(output)) as archive: + for name in order: + self.assertEqual(name.encode(), archive.read(name)) + outputs.append(output) + self.assertEqual(*outputs) + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/tests/test_droiddeck_fex.py b/tools/tests/test_droiddeck_fex.py index c9aa2200eb..0af8e7f4f6 100644 --- a/tools/tests/test_droiddeck_fex.py +++ b/tools/tests/test_droiddeck_fex.py @@ -92,6 +92,38 @@ class FexTestCase(unittest.TestCase): self.write(self.steam / "steamapps/appmanifest_1628350.acf", '"AppState" { "installdir" "SteamLinuxRuntime_sniper" }') return platform + def graphics(self, sniper, libc=b"GLIBC_2.2.5 GLIBC_2.31 GLIBC_2.34 GLIBC_2.41", libstdcxx=b"GLIBCXX_3.4.28 GLIBCXX_3.4.33"): + files = Path(sniper) / "files" + x86 = files / "lib/x86_64-linux-gnu" + self.write(x86 / "libc-2.31.so", b"GLIBC_2.2.5 GLIBC_2.31") + os.unlink(x86 / "libc.so.6") + os.symlink("libc-2.31.so", x86 / "libc.so.6") + self.write(x86 / "ld-2.31.so", b"old ld") + os.symlink("ld-2.31.so", x86 / "ld-linux-x86-64.so.2") + self.write(x86 / "libstdc++.so.6", b"GLIBCXX_3.4.28") + self.write(x86 / "libSegFault.so", b"old") + self.write(x86 / "libSDL2-2.0.so.0", b"sdl") + self.write(x86 / "libfoo.so.1.2", b"foo") + os.symlink("libfoo.so.1.2", x86 / "libfoo.so.1") + self.write(x86 / "gconv/OLD.so", b"old gconv") + self.write(files / "lib/i386-linux-gnu/libc.so.6", b"GLIBC_2.31") + self.write(files / "lib/i386-linux-gnu/ld-2.31.so", b"old ld32") + os.symlink("i386-linux-gnu/ld-2.31.so", files / "lib/ld-linux.so.2") + os.unlink(files / "lib64/ld-linux-x86-64.so.2") + os.symlink("../lib/x86_64-linux-gnu/ld-2.31.so", files / "lib64/ld-linux-x86-64.so.2") + platform = self.steam / "steamapps/common/SteamLinuxRuntime_4/steamrt4_platform_4.0.20260928.262390" + provided = platform / "files/lib/x86_64-linux-gnu" + self.write(provided / "libc.so.6", libc) + self.write(provided / "libstdc++.so.6", libstdcxx) + self.write(provided / "ld-linux-x86-64.so.2", b"new ld") + self.write(provided / "gconv/NEW.so", b"new gconv") + self.write(platform / "files/lib/i386-linux-gnu/libc.so.6", b"GLIBC_2.41") + self.write(platform / "files/lib/i386-linux-gnu/ld-linux.so.2", b"new ld32") + with gzip.open(platform / "usr-mtree.txt.gz", "wt") as out: + out.write("#mtree\n. type=dir\n") + self.write(self.steam / "steamapps/appmanifest_4183110.acf", '"AppState" { "installdir" "SteamLinuxRuntime_4" }') + return platform + def quiet(self, function, *args): with contextlib.redirect_stderr(io.StringIO()) as err: return function(*args), err.getvalue() @@ -198,12 +230,11 @@ class PrepareTest(FexTestCase): for arch in ("x86_64", "i386"): for name in ("libblsession.so", "libfakeinput.so"): self.write(self.tmp / "preloads" / arch / name, arch.encode() + name.encode()) - self.write(self.tmp / "preloads/x86_64/libthunkaudit.so", b"audit") self.write(self.tmp / "preloads/x86_64/libvulkan-thunk.so", b"pin") self.write(self.tmp / "ld.so.preload", "/usr/local/lib/libblsession.so\n/usr/local/lib/libfakeinput.so\n") FEX["install_preloads"](str(root)) - self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/libthunkaudit.so").read_bytes(), b"audit") - self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/libvulkan-thunk.so").read_bytes(), b"pin") + self.assertEqual((root / "lib/x86_64-linux-gnu/droiddeck/vulkan/libvulkan.so.1").read_bytes(), b"pin") + self.assertEqual(os.readlink(root / "lib/x86_64-linux-gnu/droiddeck/vulkan/libvulkan.so"), "libvulkan.so.1") self.assertEqual((root / "etc/ld.so.preload").read_text(), "/usr/$LIB/droiddeck/libblsession.so\n/usr/$LIB/droiddeck/libfakeinput.so\n") self.assertEqual((root / "lib/i386-linux-gnu/droiddeck/libfakeinput.so").read_bytes(), b"i386libfakeinput.so") @@ -252,7 +283,71 @@ class PrepareTest(FexTestCase): status = json.loads((self.home / ".local/share/droiddeck-fex/status.json").read_text()) self.assertEqual((status["ready"], status["runtime"], status["thunks"]), (True, str(platform), True)) self.assertFalse((self.home / ".config/droiddeck/fex-wanted").exists()) - self.assertEqual(self.quiet(FEX["prepare"])[1], "") + self.assertNotIn("prepared", self.quiet(FEX["prepare"])[1]) + + def test_a_newer_runtime_supplies_the_c_and_cxx_libraries(self): + self.fex_tool() + sniper = self.runtime() + FEX["materialize"](str(sniper)) + provider = self.graphics(sniper) + fex, said = self.quiet(FEX["prepare"]) + root = self.home / ".local/share/droiddeck-fex/rootfs" + self.assertIn("built the x86 runtime from sniper_platform_", said) + self.assertEqual(fex["rootfs"], str(root)) + config = json.loads((self.home / ".local/share/droiddeck-fex/config/Config.json").read_text()) + self.assertEqual(config["Config"]["RootFS"], str(root)) + x86 = root / "lib/x86_64-linux-gnu" + self.assertEqual((x86 / "libc.so.6").read_bytes(), b"GLIBC_2.2.5 GLIBC_2.31 GLIBC_2.34 GLIBC_2.41") + self.assertEqual((x86 / "libstdc++.so.6").read_bytes(), b"GLIBCXX_3.4.28 GLIBCXX_3.4.33") + self.assertEqual((x86 / "ld-linux-x86-64.so.2").read_bytes(), b"new ld") + self.assertEqual((x86 / "gconv/NEW.so").read_bytes(), b"new gconv") + self.assertEqual((root / "lib/i386-linux-gnu/libc.so.6").read_bytes(), b"GLIBC_2.41") + self.assertEqual((x86 / "libSDL2-2.0.so.0").read_bytes(), b"sdl") + self.assertEqual(os.readlink(x86 / "libfoo.so.1"), "libfoo.so.1.2") + self.assertEqual((x86 / "libfoo.so.1").read_bytes(), b"foo") + for stale in ("libc-2.31.so", "ld-2.31.so", "libSegFault.so"): + self.assertFalse(os.path.lexists(x86 / stale), stale) + self.assertEqual(os.readlink(root / "lib/ld-linux.so.2"), "i386-linux-gnu/ld-linux.so.2") + self.assertEqual((root / "lib/ld-linux.so.2").read_bytes(), b"new ld32") + self.assertEqual(os.readlink(root / "lib64/ld-linux-x86-64.so.2"), "../lib/x86_64-linux-gnu/ld-linux-x86-64.so.2") + self.assertEqual((root / "lib64/ld-linux-x86-64.so.2").read_bytes(), b"new ld") + self.assertEqual(os.readlink(root / "usr"), ".") + self.assertEqual((root / "usr/bin/[").read_bytes(), b"blob") + self.assertEqual((sniper / "files/lib/x86_64-linux-gnu/libc.so.6").read_bytes(), b"GLIBC_2.2.5 GLIBC_2.31") + status = json.loads((self.home / ".local/share/droiddeck-fex/status.json").read_text()) + self.assertEqual(status["graphics"], str(provider)) + self.assertNotIn("built", self.quiet(FEX["prepare"])[1]) + os.utime(provider / "usr-mtree.txt.gz", ns=(1, 1)) + self.assertIn("built the x86 runtime", self.quiet(FEX["prepare"])[1]) + self.assertEqual(sorted(os.listdir(root.parent)), ["config", "lock", "rootfs", "status.json"]) + + def test_a_runtime_that_is_not_newer_is_left_out(self): + self.fex_tool() + sniper = self.runtime() + FEX["materialize"](str(sniper)) + self.graphics(sniper, libc=b"GLIBC_2.2.5 GLIBC_2.31", libstdcxx=b"GLIBCXX_3.4.28") + fex, said = self.quiet(FEX["prepare"]) + self.assertEqual(fex["rootfs"], str(sniper / "files")) + self.assertIn("has no newer C and C++ libraries than sniper_platform_", said) + self.assertFalse((self.home / ".local/share/droiddeck-fex/rootfs").exists()) + + def test_x86_steamworks_finds_the_x86_client(self): + for directory, machine in (("linux64", 62), ("linux32", 3), ("linuxarm64", 183)): + self.write(self.steam / directory / "steamclient.so", elf(machine)) + sdk = self.home / ".steam" + sdk.mkdir(parents=True) + os.symlink(self.steam / "linuxarm64", sdk / "sdk64") + os.symlink(self.steam / "linuxarm64", sdk / "sdkarm64") + FEX["link_steam_sdk"]() + self.assertEqual(os.readlink(sdk / "sdk64"), str(self.steam / "linux64")) + self.assertEqual(os.readlink(sdk / "sdk32"), str(self.steam / "linux32")) + self.assertEqual(os.readlink(sdk / "sdkarm64"), str(self.steam / "linuxarm64")) + os.unlink(sdk / "sdk32") + os.symlink(self.tmp / "elsewhere", sdk / "sdk32") + self.write(self.tmp / "elsewhere/steamclient.so", elf(3)) + FEX["link_steam_sdk"]() + self.assertEqual(os.readlink(sdk / "sdk32"), str(self.tmp / "elsewhere")) + self.assertEqual(sorted(os.listdir(sdk)), ["sdk32", "sdk64", "sdkarm64"]) def test_status_refreshes_what_the_app_reads_once_steam_installed_fex(self): with mock.patch.dict(G, {"steam_running": lambda: False}): @@ -397,7 +492,7 @@ class LaunchTest(FexTestCase): arm = self.write(self.tmp / "arm.so", elf(183)) x86 = self.write(self.tmp / "x86.so", elf(62)) env = {"LD_PRELOAD": "%s:%s %s" % (arm, x86, self.tmp / "gone.so"), - "LD_LIBRARY_PATH": "/steam/steamrtarm64:/usr/lib/aarch64-linux-gnu:/game/lib", + "LD_LIBRARY_PATH": "/steam/steamrtarm64:/usr/lib/aarch64-linux-gnu:/game/lib:/steam/linuxarm64", "FEX_ROOTFS": "/usr/share/guestos/fex-mesa", "FEX_TSOENABLED": "1"} guest = FEX["guest_environment"]({"portable": True}, env) self.assertEqual((guest["LD_PRELOAD"], guest["LD_LIBRARY_PATH"], guest["FEX_PORTABLE"]), (str(x86), "/game/lib", "1")) @@ -405,8 +500,10 @@ class LaunchTest(FexTestCase): self.assertEqual(guest["FEX_TSOENABLED"], "1") self.assertTrue(guest["FEX_APP_CONFIG_LOCATION"].endswith("/config/")) self.assertEqual((guest["FEX_SILENTLOG"], guest["FEX_OUTPUTLOG"]), ("0", "stderr")) - guest = FEX["guest_environment"]({"portable": False}, {"LD_PRELOAD": str(arm), "FEX_PORTABLE": "1", "FEX_OUTPUTLOG": "/tmp/fex.log"}) - self.assertEqual(guest["FEX_OUTPUTLOG"], "/tmp/fex.log") + self.assertEqual(guest["GC_DISABLE_INCREMENTAL"], "1") + guest = FEX["guest_environment"]({"portable": False}, {"LD_PRELOAD": str(arm), "FEX_PORTABLE": "1", "FEX_OUTPUTLOG": "/tmp/fex.log", + "GC_DISABLE_INCREMENTAL": "0"}) + self.assertEqual((guest["FEX_OUTPUTLOG"], guest["GC_DISABLE_INCREMENTAL"]), ("/tmp/fex.log", "0")) self.assertNotIn("LD_PRELOAD", guest) self.assertNotIn("FEX_PORTABLE", guest) @@ -470,9 +567,8 @@ class LaunchTest(FexTestCase): self.runtime() self.write(tool / "usr/share/fex-emu/GuestThunks/libvulkan-guest.so", elf(62) + b"\0libstdc++.so.6\0GLIBCXX_3.4\0GLIBCXX_3.4.29\0libc.so.6\0GLIBC_2.2.5\0GLIBC_2.34\0") - self.write(self.tmp / "preloads/x86_64/libthunkaudit.so", elf(62)) - pin = self.write(self.tmp / "preloads/x86_64/libvulkan-thunk.so", elf(62)) - audit = "/usr/lib/x86_64-linux-gnu/droiddeck/libthunkaudit.so" + pin = self.write(self.tmp / "preloads/x86_64/libvulkan-thunk.so", elf(62) + b"\0libc.so.6\0GLIBC_2.2.5\0") + pinned = "/usr/lib/x86_64-linux-gnu/droiddeck/vulkan" def app(name, glibc=b"GLIBC_2.34\0GLIBC_2.44", glibcxx=b"GLIBCXX_3.4.29\0GLIBCXX_3.4.36", bundled=True): run = self.write(self.tmp / name / "AppRun", elf(62), 0o755) @@ -487,25 +583,32 @@ class LaunchTest(FexTestCase): _, said = self.quiet(FEX["launch"], [str(program)], dict(env or {}), "on", decide) return emulated.call_args[0][2], said + def search(env): + return env.get("LD_LIBRARY_PATH", "").split(":")[0] + env, said = started(app("new")) - self.assertEqual(env["LD_AUDIT"], audit) - self.assertIn("thunks on, its own Vulkan loader too", said) - env, _ = started(app("kept"), {"LD_AUDIT": "/opt/audit.so"}) - self.assertEqual(env["LD_AUDIT"], audit + ":/opt/audit.so") - env, _ = started(self.write(self.tmp / "elsewhere/run.sh", "#!/bin/sh\n", 0o755), decide=str(self.tmp / "new")) - self.assertEqual(env["LD_AUDIT"], audit) - env, said = started(app("old-cxx", glibcxx=b"GLIBCXX_3.4.28")) + self.assertEqual(search(env), pinned) self.assertNotIn("LD_AUDIT", env) + self.assertNotIn("LD_BIND_NOW", env) + self.assertIn("thunks on, its own Vulkan loader too", said) + env, _ = started(app("kept"), {"LD_LIBRARY_PATH": "/game/lib"}) + self.assertEqual(env["LD_LIBRARY_PATH"], pinned + ":/game/lib") + env, _ = started(self.write(self.tmp / "elsewhere/run.sh", "#!/bin/sh\n", 0o755), decide=str(self.tmp / "new")) + self.assertEqual(search(env), pinned) + env, said = started(app("old-cxx", glibcxx=b"GLIBCXX_3.4.28")) + self.assertNotEqual(search(env), pinned) self.assertIn("thunks on)", said) - self.assertNotIn("LD_AUDIT", started(app("old-libc", glibc=b"GLIBC_2.31"))[0]) - self.assertNotIn("LD_AUDIT", started(app("runtime-only", bundled=False))[0]) + self.assertNotEqual(search(started(app("old-libc", glibc=b"GLIBC_2.31"))[0]), pinned) + self.assertNotEqual(search(started(app("runtime-only", bundled=False))[0]), pinned) i386 = self.write(self.tmp / "new/game.i386", elf(3), 0o755) - self.assertNotIn("LD_AUDIT", started(i386)[0]) + self.assertNotEqual(search(started(i386)[0]), pinned) + self.write(pin, elf(62) + b"\0libc.so.6\0GLIBC_2.45\0") + self.assertNotEqual(search(started(app("new"))[0]), pinned) pin.unlink() - self.assertNotIn("LD_AUDIT", started(app("no-pin"))[0]) + self.assertNotEqual(search(started(app("no-pin"))[0]), pinned) self.write(pin, elf(62)) (tool / "usr/share/fex-emu/GuestThunks/libvulkan-guest.so").unlink() - self.assertNotIn("LD_AUDIT", started(app("no-thunk"))[0]) + self.assertNotEqual(search(started(app("no-thunk"))[0]), pinned) def test_steam_verbs(self): with mock.patch.dict(G, {"launch": mock.Mock(return_value=0)}): @@ -573,6 +676,53 @@ class AppInfoTest(unittest.TestCase): "40": None, "41": None, "50": "droiddeck-fex", }, hex(magic)) + @staticmethod + def manifest(steam, app, flags="4"): + (steam / "steamapps").mkdir(exist_ok=True) + (steam / ("steamapps/appmanifest_%s.acf" % app)).write_text('"AppState" { "appid" "%s" "StateFlags" "%s" }' % (app, flags)) + + def test_dual_platform_titles_keep_the_proton_default_unless_the_user_picks_fex(self): + with tempfile.TemporaryDirectory() as tmp: + steam = Path(tmp) / "Steam" + (steam / "appcache").mkdir(parents=True) + (steam / "appcache/appinfo.vdf").write_bytes(self.appinfo({ + 10: ("windows,linux", "", "game"), 20: ("windows,linux", "", "game"), 30: ("windows,linux", "", "game"), + 40: ("linux", "", "game"), + })) + self.COMPAT["APPINFO_CACHE"].clear() + for app in ("3127680", "1628350", "4183110"): + self.manifest(steam, app) + tool, fex = self.COMPAT["TOOL"], self.COMPAT["FEX_TOOL"] + state = Path(tmp) / "state" + state.mkdir() + (state / "state.json").write_text(json.dumps({"auto": {"20": fex}})) + catalog = [{"name": tool, "display": "Proton Experimental ARM64", "dir": "Proton Experimental (ARM64)", "valve": True}] + config = steam / "config/config.vdf" + config.parent.mkdir() + config.write_text('"InstallConfigStore" { "Software" { "Valve" { "Steam" { "CompatToolMapping" { ' + '"0" { "name" "%s" "config" "" "priority" "75" } ' + '"20" { "name" "%s" "config" "" "priority" "250" } ' + '"30" { "name" "%s" "config" "" "priority" "250" } } } } } }' % (tool, fex, fex)) + self.COMPAT["register_default"](str(config), ["10", "20", "30", "40"], catalog=catalog, directory=str(state)) + self.assertEqual(self.COMPAT["read_config_mapping"](str(config)), + {"0": tool, "10": tool, "20": tool, "30": fex, "40": fex}) + + def test_tools_are_fetched_until_fully_installed_and_up_to_date(self): + with tempfile.TemporaryDirectory() as tmp: + steam = Path(tmp) + (steam / "steamapps").mkdir() + downloads = self.COMPAT["tool_downloads"] + self.assertEqual(downloads(str(steam)), [ + ("4427310", "install"), ("3127680", "install"), ("1628350", "install"), ("4183110", "install")]) + self.manifest(steam, "4427310", flags="6") + self.manifest(steam, "3127680", flags="1026") + self.manifest(steam, "1628350", flags="4") + (steam / "steamapps/appmanifest_4183110.acf").write_text('"AppState" { "appid" "4183110" }') + self.assertEqual(downloads(str(steam)), [("4427310", "update"), ("3127680", "update"), ("4183110", "update")]) + for app in ("4427310", "3127680", "4183110"): + self.manifest(steam, app) + self.assertEqual(downloads(str(steam)), []) + def test_titles_with_a_valve_pick_are_found_installed_or_not(self): def deck(oslist, runtime, kind="game"): common = {"type": kind, "oslist": oslist, "steam_deck_compatibility": {"configuration": {"recommended_runtime": runtime}}} diff --git a/tools/tests/test_fakeinput_ring.py b/tools/tests/test_fakeinput_ring.py new file mode 100644 index 0000000000..3c87bd11e2 --- /dev/null +++ b/tools/tests/test_fakeinput_ring.py @@ -0,0 +1,144 @@ +import os +from pathlib import Path +import shutil +import struct +import subprocess +import sys +import tempfile +import unittest + +SOURCE = Path(__file__).resolve().parents[2] / "app/src/main/cpp/fakeinput_steam.cpp" +RING_MAGIC = 0x46494252 +DESCRIPTION_MAGIC = 0x46495544 +HEADER = 64 +EVENT = 24 +CAPACITY = 4096 +DESCRIPTION = 1824 +READER = r""" +#include +#include +#include +#include + +int main(void) +{ + struct input_event events[64]; + int fd = open("/dev/input/event16", O_RDONLY | O_NONBLOCK); + if (fd < 0) { + perror("open"); + return 1; + } + while (read(fd, events, sizeof(events)) > 0) + ; + puts("ready"); + fflush(stdout); + char go; + if (read(0, &go, 1) != 1) + return 1; + ssize_t got = read(fd, events, sizeof(events)); + for (ssize_t i = 0; i < got / (ssize_t)sizeof(events[0]); i++) + printf("%ld.%06ld %u %u %d\n", (long)events[i].time.tv_sec, (long)events[i].time.tv_usec, events[i].type, + events[i].code, events[i].value); + return got > 0 ? 0 : 1; +} +""" +PROBE = r""" +#include +#include +#include +#include +#include +#include + +int main(void) +{ + char name[128] = ""; + struct input_id id = {0}; + int fd = open("/dev/input/event16", O_RDONLY | O_NONBLOCK); + if (fd < 0) + return 1; + int joydev = ioctl(fd, JSIOCGNAME(sizeof(name)), name); + printf("JSIOCGNAME %d %s\n", joydev, joydev < 0 && errno == EINVAL ? "EINVAL" : name); + if (ioctl(fd, EVIOCGID, &id) < 0 || ioctl(fd, EVIOCGNAME(sizeof(name)), name) < 0) + return 1; + printf("%04x:%04x %s\n", id.vendor, id.product, name); + return 0; +} +""" + + +def can_build(bits): + with tempfile.TemporaryDirectory() as tmp: + probe = Path(tmp) / "probe.cpp" + probe.write_text("#include \nint main() { return std::string().size(); }\n") + return subprocess.run(["g++", bits, "-static-libstdc++", "-o", str(Path(tmp) / "probe"), str(probe)], + capture_output=True).returncode == 0 + + +@unittest.skipUnless(sys.platform == "linux" and os.uname().machine == "x86_64" and shutil.which("g++") + and shutil.which("gcc"), "needs gcc and g++ on an x86-64 Linux host") +class FakeinputRingTest(unittest.TestCase): + def setUp(self): + self.tmp = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.tmp, True) + + def ring(self): + hooks = self.tmp / "hooks" + hooks.mkdir() + (hooks / "event16").touch() + ring = bytearray(HEADER + CAPACITY * EVENT + DESCRIPTION) + struct.pack_into(" "$ROOT/tag"; : > "$ROOT/FEX"; chmod +x "$ROOT/FEX"; return 0 ;; esac + return 1 + } + """) + + +class FexSelectTest(unittest.TestCase): + def run_select(self, installed=None, loads=False, catalog=None, installable=()): + with tempfile.TemporaryDirectory() as root: + if installed: + Path(root, "tag").write_text(installed + "\n") + fex = Path(root, "FEX") + fex.write_text("") + fex.chmod(0o755) + body = (X64_FEX.replace("/usr/local/share/fex-emu/.droiddeck-tag", "$ROOT/tag") + .replace("/usr/local/bin/FEX", "$ROOT/FEX")) + script = HARNESS + body + 'if x64_fex; then echo "NOW $FEX_NOW|$FEX_FROM"; else echo FAILED; fi\n' + env = dict(os.environ, ROOT=root, LOADS="1" if loads else "0", INSTALLABLE=" ".join(installable)) + env.pop("BL_FEX_TAG", None) + if catalog: + env.update(BL_FEX_TAG=catalog, BL_FEX_SHA256="catsha", BL_FEX_URLS="a b") + out = subprocess.run(["bash", "-c", script], env=env, text=True, capture_output=True, timeout=10) + self.assertEqual(0, out.returncode, out.stderr) + lines = out.stdout.splitlines() + return [l for l in lines if l.startswith("INSTALL")], lines[-1] + + def test_the_catalog_build_already_installed_is_used(self): + installs, now = self.run_select(installed="fex-2610-r6", loads=True, catalog="fex-2610-r6") + self.assertEqual([], installs) + self.assertEqual("NOW fex-2610-r6|catalog", now) + + def test_a_newer_catalog_build_is_installed(self): + installs, now = self.run_select(installed="fex-2610-r5", loads=True, catalog="fex-2610-r6", installable=["fex-2610-r6"]) + self.assertEqual(["INSTALL fex-2610-r6 catsha a b"], installs) + self.assertEqual("NOW fex-2610-r6|catalog", now) + + def test_a_catalog_build_that_does_not_install_keeps_the_working_one(self): + installs, now = self.run_select(installed="fex-2610-r5", loads=True, catalog="fex-2610-r6") + self.assertEqual(["INSTALL fex-2610-r6 catsha a b"], installs) + self.assertEqual("NOW fex-2610-r5|kept; fex-2610-r6 did not install", now) + + def test_without_a_catalog_the_built_in_build_replaces_an_older_one(self): + installs, now = self.run_select(installed="fex-2610-r4", loads=True, installable=["fex-2610-r5"]) + self.assertEqual(["INSTALL fex-2610-r5 builtin builtin-url"], installs) + self.assertEqual("NOW fex-2610-r5|built-in", now) + + def test_an_installed_build_that_does_not_load_is_replaced(self): + installs, now = self.run_select(installed="fex-2610-r6", loads=False, catalog="fex-2610-r6", installable=["fex-2610-r6"]) + self.assertEqual(["INSTALL fex-2610-r6 catsha a b"], installs) + self.assertEqual("NOW fex-2610-r6|catalog", now) + + def test_a_first_install_falls_back_to_the_built_in_build(self): + installs, now = self.run_select(catalog="fex-2610-r6", installable=["fex-2610-r5"]) + self.assertEqual(["INSTALL fex-2610-r6 catsha a b", "INSTALL fex-2610-r5 builtin builtin-url"], installs) + self.assertEqual("NOW fex-2610-r5|built-in", now) + + def test_nothing_usable_fails(self): + installs, now = self.run_select(catalog="fex-2610-r6") + self.assertEqual(2, len(installs)) + self.assertEqual("FAILED", now) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_game_environment.py b/tools/tests/test_game_environment.py index 2472c2aef3..936dfe7bd0 100644 --- a/tools/tests/test_game_environment.py +++ b/tools/tests/test_game_environment.py @@ -637,7 +637,7 @@ class ProtonDefaultTest(unittest.TestCase): (root / "state.json").write_text(json.dumps({ "default": self.TOOL, "auto": {}, - "native": [app], + "native_choices": [app], })) globals_ = COMPAT["register_default"].__globals__ @@ -649,7 +649,7 @@ class ProtonDefaultTest(unittest.TestCase): self.assertEqual(mapping_of(config.read_text()), {"0": self.TOOL}) state = json.loads((root / "state.json").read_text()) self.assertEqual(state["auto"], {}) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) finally: globals_["native_targets"] = original_native_targets @@ -666,7 +666,7 @@ class ProtonDefaultTest(unittest.TestCase): (root / "state.json").write_text(json.dumps({ "default": self.TOOL, "auto": {}, - "native": [app], + "native_choices": [app], })) globals_ = COMPAT["register_default"].__globals__ @@ -677,12 +677,12 @@ class ProtonDefaultTest(unittest.TestCase): try: COMPAT["register_default"]( str(config), [app], catalog=self.CATALOG, directory=tmp) - self.assertEqual(json.loads((root / "state.json").read_text())["native"], [app]) + self.assertEqual(json.loads((root / "state.json").read_text())["native_choices"], [app]) COMPAT["register_default"]( str(config), [added_shortcut], catalog=self.CATALOG, directory=tmp) state = json.loads((root / "state.json").read_text()) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) self.assertEqual(state["auto"], {added_shortcut: self.TOOL}) self.assertEqual(mapping_of(config.read_text()), { "0": self.TOOL, @@ -728,7 +728,7 @@ class ProtonDefaultTest(unittest.TestCase): self.assertEqual(COMPAT["tokenize"](first.decode()), COMPAT["tokenize"](config_text([("0", self.TOOL)]))) self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["auto"], {}) - self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["native"], ["427520"]) + self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["native_choices"], ["427520"]) COMPAT["register_default"]( str(config), ["427520"], catalog=self.CATALOG, directory=tmp) @@ -740,7 +740,7 @@ class ProtonDefaultTest(unittest.TestCase): native_choice = config.read_bytes() self.assertEqual(mapping_of(native_choice.decode()), {"0": self.TOOL, "427520": ""}) self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["auto"], {}) - self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["native"], ["427520"]) + self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["native_choices"], ["427520"]) COMPAT["register_default"]( str(config), ["427520"], catalog=self.CATALOG, directory=tmp) self.assertEqual(config.read_bytes(), native_choice) @@ -750,10 +750,10 @@ class ProtonDefaultTest(unittest.TestCase): COMPAT["register_default"]( str(config), ["427520"], catalog=self.CATALOG, directory=tmp) self.assertEqual(mapping_of(config.read_text()), {"0": self.TOOL, "427520": choice}) - self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["native"], []) + self.assertEqual(json.loads((Path(tmp) / "state.json").read_text())["native_choices"], []) state = json.loads((Path(tmp) / "state.json").read_text()) - state["native"] = ["427520"] + state["native_choices"] = ["427520"] state["auto"] = {} (Path(tmp) / "state.json").write_text(json.dumps(state)) config.write_text(config_text([("0", self.TOOL), ("427520", "proton_experimental")])) @@ -761,7 +761,7 @@ class ProtonDefaultTest(unittest.TestCase): str(config), ["427520"], catalog=self.CATALOG, directory=tmp) self.assertEqual(mapping_of(config.read_text()), {"0": self.TOOL, "427520": self.TOOL}) saved = json.loads((Path(tmp) / "state.json").read_text()) - self.assertEqual(saved["native"], []) + self.assertEqual(saved["native_choices"], []) self.assertEqual(saved["auto"], {"427520": self.TOOL}) finally: globals_["appinfo_platforms"] = original_platforms diff --git a/tools/tests/test_glasses_localization.py b/tools/tests/test_glasses_localization.py new file mode 100644 index 0000000000..0708286fab --- /dev/null +++ b/tools/tests/test_glasses_localization.py @@ -0,0 +1,71 @@ +import collections +from pathlib import Path +import re +import unicodedata +import unittest +import xml.etree.ElementTree as ET + + +ROOT = Path(__file__).resolve().parents[2] +RES = ROOT / "app/src/main/res" +FORMAT = re.compile(r"%(?:\d+\$)?[-#+ 0,(]*\d*(?:\.\d+)?[a-zA-Z%]") + + +def strings(path): + return { + element.attrib["name"]: "".join(element.itertext()) + for element in ET.parse(path).getroot() + if element.tag == "string" and element.get("translatable") != "false" + } + + +class GlassesLocalizationTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.english = strings(RES / "values/strings.xml") + cls.required = { + key: value for key, value in cls.english.items() + if key.startswith(("glasses_", "spatial_", "tracking_recovery_", "setup_glasses_", "phone_camera_tracking_")) + or key in ("setup_tab_glasses", "hand_camera_prompt_title", "hand_camera_prompt_body", "hand_camera_setting_hint") + } + language_source = (ROOT / "app/src/main/java/com/droiddeck/launcher/core/AppLanguage.kt").read_text(encoding="utf-8") + tags = re.findall(r'"([a-zA-Z0-9-]+)"', re.search(r"val supported:.*?listOf\((.*?)\)", language_source, re.S).group(1)) + special = {"id": "in", "es-419": "b+es+419", "pt-BR": "pt"} + cls.locales = {} + for tag in tags: + if tag == "en": + continue + qualifier = special.get(tag, tag.replace("-", "-r")) + cls.locales[tag] = strings(RES / f"values-{qualifier}/strings.xml") + + def test_every_supported_language_has_nonempty_glasses_and_calibration_text(self): + for locale, translated in self.locales.items(): + for key in self.required: + with self.subTest(locale=locale, key=key): + self.assertTrue(translated.get(key, "").strip(), "Missing translation would fall back to English") + + def test_translations_preserve_format_arguments_and_explicit_line_breaks(self): + for locale, translated in self.locales.items(): + for key, source in self.required.items(): + with self.subTest(locale=locale, key=key): + target = translated.get(key, "") + self.assertEqual(collections.Counter(FORMAT.findall(source)), collections.Counter(FORMAT.findall(target))) + self.assertEqual(source.count(r"\n"), target.count(r"\n")) + + def test_printed_board_and_distance_guidance_preserve_measurements(self): + keys = ("spatial_print_hint", "spatial_print_scale", "spatial_print_check", "spatial_distance_12in", + "spatial_distance_30cm", "spatial_distance_20in", "spatial_distance_50cm", + "spatial_distance_hint", "spatial_distance_corners") + + def numbers(value): + value = "".join(str(unicodedata.decimal(char)) if char.isdecimal() else char for char in value) + return collections.Counter(number.replace(",", ".") for number in re.findall(r"\d+(?:[.,]\d+)?", value)) + + for locale, translated in self.locales.items(): + for key in keys: + with self.subTest(locale=locale, key=key): + self.assertEqual(numbers(self.english[key]), numbers(translated.get(key, ""))) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_mjpeg_payload.cpp b/tools/tests/test_mjpeg_payload.cpp new file mode 100644 index 0000000000..7d45fe4441 --- /dev/null +++ b/tools/tests/test_mjpeg_payload.cpp @@ -0,0 +1,23 @@ +#include "../../app/src/main/cpp/viture/mjpeg_payload.h" +#include +#include +#include + +int main() { + const uint8_t jpeg[] = {0xff,0xd8,0xff,0xc0,0,4,1,2,0xff,0xd9}; + uint8_t frame[32]{}; + std::memcpy(frame,jpeg,sizeof(jpeg)); + for (std::size_t padding=0; padding<=7; ++padding) + assert(mjpeg_payload_size(frame,sizeof(jpeg)+padding) == sizeof(jpeg)); + assert(mjpeg_payload_size(frame,sizeof(jpeg)+8) == 0); + for (std::size_t size=0; size eval(script), /install calls are not ready/); +const opened = [], queued = []; +let wizard = null, continued = 0; +globalThis.SteamClient = { + Installs: { + OpenInstallWizard(apps, client) { opened.push([apps, client]); }, + RegisterForShowInstallWizard(callback) { assert.strictEqual(wizard, null); wizard = callback; return { unregister() {} }; }, + ContinueInstall() { continued++; }, + }, + Downloads: { QueueAppUpdate(app, client) { queued.push([app, client]); } }, +}; +assert.strictEqual(eval(script), 'installed'); +assert.strictEqual(eval(script), 'present'); +const tools = window.__droiddeckTools; +wizard({ eInstallState: 7, currentAppID: 4183110 }); +assert.strictEqual(continued, 0); +tools.install(4183110); +assert.deepStrictEqual(opened, [[[4183110], '0']]); +wizard({ eInstallState: 8, currentAppID: 4183110 }); +wizard({ eInstallState: 7, currentAppID: 892970 }); +assert.strictEqual(continued, 0); +wizard({ eInstallState: 7, currentAppID: 4183110 }); +wizard({ eInstallState: 7, currentAppID: 4183110 }); +assert.strictEqual(continued, 1); +tools.update(4427310); +assert.deepStrictEqual(queued, [[4427310, '0']]); +""" + with tempfile.TemporaryDirectory() as tmp: + script = Path(tmp) / "tools.js" + script.write_text(LIVE["TOOLS_JS"]) + harness = Path(tmp) / "harness.js" + harness.write_text(harness_source) + result = subprocess.run(["node", str(harness), str(script)], capture_output=True, text=True, timeout=20) + self.assertEqual(result.returncode, 0, result.stderr) + def test_steamvr_library_launch_uses_binding_and_other_games_pass_through(self): harness_source = r""" const assert = require('assert'); @@ -334,19 +375,19 @@ class ReconcileTest(unittest.TestCase): state = self.reconcile(page) self.assertEqual(page.sets, []) self.assertEqual(state["auto"], {}) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": TOOL}) page.sets.clear() state = self.reconcile(page) self.assertEqual(page.sets, []) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) restarted = LIVE["Helper"](str(self.steam), 1) restarted.page = page restarted.reconcile() state = json.loads((self.state / "state.json").read_text()) self.assertEqual(page.sets, []) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) config.write_text( '"InstallConfigStore" { "Software" { "Valve" { "Steam" { ' @@ -356,13 +397,13 @@ class ReconcileTest(unittest.TestCase): state = self.reconcile(page) self.assertEqual(page.mapping[app], "GE-Proton11-7") self.assertEqual(page.sets, []) - self.assertEqual(state["native"], []) + self.assertEqual(state["native_choices"], []) for choice in ("steamlinuxruntime", COMPAT["FEX_TOOL"], TOOL_11): (self.state / "state.json").write_text(json.dumps({ "default": TOOL, "auto": {}, - "native": [app], + "native_choices": [app], })) config.write_text( '"InstallConfigStore" { "Software" { "Valve" { "Steam" { ' @@ -373,7 +414,7 @@ class ReconcileTest(unittest.TestCase): state = self.reconcile(page) self.assertEqual(page.mapping[app], choice) self.assertEqual(page.sets, []) - self.assertEqual(state["native"], [], choice) + self.assertEqual(state["native_choices"], [], choice) finally: COMPAT["native_targets"] = original_native_targets @@ -387,7 +428,7 @@ class ReconcileTest(unittest.TestCase): (self.state / "state.json").write_text(json.dumps({ "default": TOOL, "auto": {}, - "native": [app], + "native_choices": [app], })) original_native_targets = COMPAT["native_targets"] @@ -396,14 +437,14 @@ class ReconcileTest(unittest.TestCase): page = FakePage({"0": TOOL, app: "proton"}, [TOOL, TOOL_11]) state = self.reconcile(page) self.assertNotIn(app, self.helper.installed) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) self.assertNotIn(app, state["auto"]) self.assertNotIn((app, TOOL), page.sets) self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": TOOL}) config.write_text('"InstallConfigStore" { "Software" { "Other" {} } }') state = self.reconcile(page) - self.assertEqual(state["native"], [app]) + self.assertEqual(state["native_choices"], [app]) self.assertNotIn((app, TOOL), page.sets) config.write_text( @@ -412,12 +453,72 @@ class ReconcileTest(unittest.TestCase): '"%s" { "name" "GE-Proton11-7" } } } } } }' % (TOOL, app)) page.mapping[app] = "proton" state = self.reconcile(page) - self.assertEqual(state["native"], []) + self.assertEqual(state["native_choices"], []) self.assertNotIn((app, TOOL), page.sets) self.assertEqual(COMPAT["read_config_mapping"](str(config))[app], "GE-Proton11-7") finally: COMPAT["native_targets"] = original_native_targets + def dual_platform_game(self, state): + app = "892970" + (self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("") + config = self.steam / "config/config.vdf" + config.parent.mkdir(parents=True) + config.write_text( + '"InstallConfigStore" { "Software" { "Valve" { "Steam" { ' + '"CompatToolMapping" { "0" { "name" "%s" } } } } } }' % TOOL) + (self.state / "state.json").write_text(json.dumps(state)) + patcher = mock.patch.dict(COMPAT, {"native_targets": lambda _root, apps: { + app: COMPAT["NATIVE_CHOICE"] + } if app in apps else {}}) + patcher.start() + self.addCleanup(patcher.stop) + return app, FakePage({"0": TOOL, "10": TOOL, "11": TOOL}, [TOOL, TOOL_11]) + + def test_unmapped_dual_platform_game_gets_the_default_live(self): + app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}}) + state = self.reconcile(page) + self.assertEqual(page.sets, [(app, TOOL)]) + self.assertEqual(state["auto"][app], TOOL) + self.assertEqual(state["native_choices"], []) + + page.mapping[app] = "" + page.sets.clear() + state = self.reconcile(page) + self.assertEqual(page.sets, []) + self.assertEqual(state["native_choices"], [app]) + + def test_unmapped_dual_platform_game_gets_the_default_without_a_readable_config(self): + app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL}, "native_choices": ["11"]}) + (self.steam / "config/config.vdf").unlink() + page.mapping["11"] = "" + state = self.reconcile(page) + self.assertEqual(page.sets, [(app, TOOL)]) + self.assertEqual(state["auto"][app], TOOL) + self.assertEqual(state["native_choices"], ["11"]) + + def test_a_tool_set_live_is_kept_before_the_client_writes_its_config(self): + app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL, "892970": TOOL}}) + page.known.append(COMPAT["FEX_TOOL"]) + page.mapping[app] = TOOL + config = self.steam / "config/config.vdf" + config.write_text( + '"InstallConfigStore" { "Software" { "Valve" { "Steam" { ' + '"CompatToolMapping" { "0" { "name" "%s" } "%s" { "name" "%s" } } } } } }' % (TOOL, app, TOOL)) + with mock.patch.dict(COMPAT, {"native_targets": lambda _root, apps: {app: COMPAT["FEX_TOOL"]} if app in apps else {}}): + state = self.reconcile(page) + self.assertEqual(page.sets, [(app, COMPAT["FEX_TOOL"])]) + state = self.reconcile(page) + self.assertEqual(page.sets, [(app, COMPAT["FEX_TOOL"])]) + self.assertEqual(state["auto"][app], COMPAT["FEX_TOOL"]) + + def test_native_list_from_earlier_builds_is_not_trusted(self): + app, page = self.dual_platform_game({"default": TOOL, "auto": {"10": TOOL, "11": TOOL}, "native": ["892970"]}) + state = self.reconcile(page) + self.assertEqual(page.sets, [(app, TOOL)]) + self.assertNotIn("native", state) + self.assertEqual(state["native_choices"], []) + def test_factorio_without_prior_auto_state_uses_the_default_proton(self): app = "427520" (self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text("") @@ -436,7 +537,7 @@ class ReconcileTest(unittest.TestCase): state = self.reconcile(page) self.assertEqual(page.sets, [(app, TOOL)]) self.assertEqual(state["auto"], {app: TOOL}) - self.assertEqual(state["native"], []) + self.assertEqual(state["native_choices"], []) self.assertEqual(COMPAT["read_config_mapping"](str(config)), {"0": TOOL}) finally: COMPAT["native_targets"] = original_native_targets @@ -485,6 +586,79 @@ console.log(JSON.stringify({ sent: sent.length, asked: asked.length })); """ +class ToolPage(FakePage): + def __init__(self, fail=False): + super().__init__({"0": TOOL}, [TOOL]) + self.calls = [] + self.fail = fail + + def tools(self, call): + self.calls.append(call) + if self.fail: + raise RuntimeError("the client's install calls are not ready") + return True + + +class ToolDownloadTest(unittest.TestCase): + def setUp(self): + tmp = tempfile.TemporaryDirectory() + self.addCleanup(tmp.cleanup) + self.steam = Path(tmp.name) / "Steam" + (self.steam / "steamapps").mkdir(parents=True) + self.helper = LIVE["Helper"](str(self.steam), 1) + self.now = [1000.0] + self.running = [False] + self.requested = [] + patcher = mock.patch.dict(COMPAT, { + "game_running": lambda: self.running[0], + "request_fex": lambda root, asked: self.requested.append(root) or ["3127680"], + }) + patcher.start() + self.addCleanup(patcher.stop) + clock = mock.patch.object(LIVE["time"], "monotonic", lambda: self.now[0]) + clock.start() + self.addCleanup(clock.stop) + + def manifest(self, app, flags): + (self.steam / ("steamapps/appmanifest_%s.acf" % app)).write_text('"AppState" { "StateFlags" "%s" }' % flags) + + def test_missing_tools_are_installed_and_deferred_ones_queued(self): + self.manifest("4427310", "6") + self.manifest("3127680", "4") + self.manifest("1628350", "1026") + self.helper.page = page = ToolPage() + self.helper.ensure_tools() + self.assertEqual(page.calls, ["update(4427310)", "update(1628350)", "install(4183110)"]) + self.now[0] += 30 + self.helper.ensure_tools() + self.now[0] += 60 + self.helper.ensure_tools() + self.assertEqual(len(page.calls), 3) + self.now[0] += 300 + self.manifest("4427310", "4") + self.helper.ensure_tools() + self.assertEqual(page.calls[3:], ["update(1628350)", "install(4183110)"]) + self.assertEqual(self.requested, []) + + def test_nothing_is_queued_while_a_game_runs(self): + self.running[0] = True + self.helper.page = page = ToolPage() + self.helper.ensure_tools() + self.assertEqual(page.calls, []) + self.running[0] = False + self.now[0] += 60 + self.helper.ensure_tools() + self.assertEqual(len(page.calls), 4) + + def test_an_install_falls_back_to_the_steam_url(self): + for app in ("4427310", "1628350", "4183110"): + self.manifest(app, "4") + self.helper.page = page = ToolPage(fail=True) + self.helper.ensure_tools() + self.assertEqual(page.calls, ["install(3127680)"]) + self.assertEqual(self.requested, [str(self.steam)]) + + @unittest.skipUnless(shutil.which("node"), "node is not installed") class SwitchScriptTest(unittest.TestCase): def test_the_request_is_reported_and_still_sent(self): diff --git a/tools/tests/test_steam_libraries.py b/tools/tests/test_steam_libraries.py index 3987470ba6..4f416a8401 100644 --- a/tools/tests/test_steam_libraries.py +++ b/tools/tests/test_steam_libraries.py @@ -121,7 +121,7 @@ class CompatLibrariesTest(unittest.TestCase): manifest(self.pc / "steamapps", 30) manifest(self.pc / "steamapps", 3127680, installdir="FEX") self.assertEqual(["20", "30"], COMPAT["installed_apps"](str(self.steam))) - self.assertEqual(["1628350"], COMPAT["fex_missing"](str(self.steam))) + self.assertEqual(["1628350", "4183110"], COMPAT["fex_missing"](str(self.steam))) def test_newest_proton_across_libraries_wins(self): for root, build in ((self.steam, "100"), (self.pc, "200")): diff --git a/tools/tests/test_steamvr_graphics.py b/tools/tests/test_steamvr_graphics.py new file mode 100644 index 0000000000..9cdcd168f7 --- /dev/null +++ b/tools/tests/test_steamvr_graphics.py @@ -0,0 +1,79 @@ +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import time +import unittest + + +HELPER = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/droiddeck-steamvr' + + +@unittest.skipUnless(shutil.which('sh'), 'requires a POSIX shell') +class SteamVrGraphicsTest(unittest.TestCase): + def launch(self, model, debug=None, action='start', preload=None): + with tempfile.TemporaryDirectory() as directory: + root = Path(directory) + bindir = root / 'bin' + bindir.mkdir() + runtime = root / 'steamvr/bin/linuxarm64' + runtime.mkdir(parents=True) + (runtime / 'vrstartup').touch(mode=0o755) + driver = root / 'driver/droiddeck/bin/linuxarm64' + driver.mkdir(parents=True) + (driver / 'driver_droiddeck.so').touch() + result = root / 'launch-env' + preloads = root / 'launch-preload' + scripts = { + 'cat': 'if [ "$1" = /sys/class/kgsl/kgsl-3d0/gpu_model ]; then printf "%s" "$TEST_GPU_MODEL"; else exec /bin/cat "$@"; fi', + 'pgrep': 'exit 1', + 'setsid': 'printf "%s" "$LD_PRELOAD" > "$TEST_LAUNCH_PRELOAD"; printf "%s" "${TU_DEBUG-unset}" > "$TEST_LAUNCH_ENV"', + } + for name, script in scripts.items(): + path = bindir / name + path.write_text('#!/bin/sh\n' + script + '\n') + path.chmod(0o755) + env = dict(os.environ, HOME=str(root), XDG_RUNTIME_DIR=str(root / 'run'), + STEAMVR=str(root / 'steamvr'), DROIDDECK_VR_DIR=str(root / 'driver'), + PATH=str(bindir) + os.pathsep + os.environ['PATH'], + TEST_GPU_MODEL=model, TEST_LAUNCH_ENV=str(result), TEST_LAUNCH_PRELOAD=str(preloads)) + env.pop('TU_DEBUG', None) + env.pop('LD_PRELOAD', None) + if debug is not None: + env['TU_DEBUG'] = debug + if preload is not None: + env['LD_PRELOAD'] = preload + run = subprocess.run(['sh', str(HELPER), action], env=env, + capture_output=True, text=True, timeout=10) + self.assertEqual(run.returncode, 0, run.stderr) + until = time.monotonic() + 2 + while not result.exists() and time.monotonic() < until: + time.sleep(0.01) + self.assertEqual(preloads.read_text(), str(root / 'driver/layer/libdroiddeck_vr_scheduling.so') + + (':' + preload if preload else '')) + return result.read_text() + + def test_adreno_840_start_removes_forced_sysmem(self): + self.assertEqual(self.launch('Adreno840v2', 'sysmem'), '') + self.assertEqual(self.launch('Adreno840v2'), '') + + def test_preserves_other_debug_flags_and_removes_repeated_sysmem(self): + self.assertEqual(self.launch('Adreno840v2', 'sysmem,forcecb,sysmem,noubwc'), 'forcecb,noubwc') + self.assertEqual(self.launch('Adreno840v2', 'forcecb sysmem flushall'), 'forcecb,flushall') + + def test_library_launch_uses_the_same_graphics_setup(self): + self.assertEqual(self.launch('Adreno840v2', 'sysmem,forcecb', action='launch'), 'forcecb') + + def test_scheduling_preload_preserves_existing_preloads(self): + self.assertEqual(self.launch('Adreno840v2', 'sysmem', action='launch', + preload='/existing/preload.so'), '') + + def test_other_and_unknown_gpus_keep_their_environment(self): + self.assertEqual(self.launch('Adreno740'), 'unset') + self.assertEqual(self.launch('Adreno740', 'sysmem,forcecb'), 'sysmem,forcecb') + self.assertEqual(self.launch('', 'sysmem'), 'sysmem') + + +if __name__ == '__main__': + unittest.main() diff --git a/tools/tests/test_steamvr_helper.py b/tools/tests/test_steamvr_helper.py index 9a657de609..3fa3e82255 100644 --- a/tools/tests/test_steamvr_helper.py +++ b/tools/tests/test_steamvr_helper.py @@ -14,6 +14,14 @@ SOURCE = Path(__file__).resolve().parents[1] / 'linuxfs/overlay/usr/local/bin/dr class SteamVrHelperTest(unittest.TestCase): + @classmethod + def setUpClass(cls): + cls.compiler_output = tempfile.TemporaryDirectory() + cls.addClassCleanup(cls.compiler_output.cleanup) + cls.scheduling = Path(cls.compiler_output.name) / 'libdroiddeck_vr_scheduling.so' + source = Path(__file__).resolve().parents[1] / 'vr/src/scheduling.c' + subprocess.run(['cc', '-shared', '-fPIC', '-o', str(cls.scheduling), str(source), '-ldl'], check=True) + def setUp(self): self.temporary = tempfile.TemporaryDirectory() self.addCleanup(self.temporary.cleanup) @@ -37,6 +45,9 @@ class SteamVrHelperTest(unittest.TestCase): self.executable(self.steamvr / 'bin/linuxarm64/vrstartup', 'echo "display=${DROIDDECK_VR_DISPLAY_MODE:-unset}"') (self.driver / 'driver_droiddeck.so').touch() + layer = self.root / 'driver/layer' + layer.mkdir() + shutil.copyfile(self.scheduling, layer / self.scheduling.name) self.environment = dict(os.environ) self.environment.pop('DROIDDECK_VR_DISPLAY_MODE', None) self.environment.pop('DROIDDECK_VR_PRESENT', None) diff --git a/tools/tests/test_stereo_frame_gate.cpp b/tools/tests/test_stereo_frame_gate.cpp new file mode 100644 index 0000000000..1603bd657e --- /dev/null +++ b/tools/tests/test_stereo_frame_gate.cpp @@ -0,0 +1,66 @@ +#include "../../app/src/main/cpp/viture/stereo_frame_gate.h" +#include +#include +#include +#include + +int main() { + StereoFrameGate gate; + gate.SetHalfRate(true); + int copies = 0; + for (int i = 0; i < 250; ++i) { + const bool accepted = gate.Accept(1 + i*.04); + assert(accepted == (i%2 == 0)); + copies += accepted; + } + assert(copies == 125 && gate.received == 250 && gate.skipped == 125); + gate.SetHalfRate(false); + for (int i = 0; i < 25; ++i) assert(gate.Accept(20 + i*.04)); + assert(gate.received == 275 && gate.skipped == 125); + gate.SetHalfRate(true); + assert(gate.Accept(30)); + gate.SetHalfRate(true); + assert(!gate.Accept(30.04)); + assert(gate.Accept(30.08)); + assert(gate.Accept(1)); + assert(!gate.Accept(1.04)); + const auto count = gate.received; + assert(!gate.Accept(std::numeric_limits::quiet_NaN())); + assert(!gate.Accept(0)); + assert(gate.received == count); + gate = {}; + gate.SetHalfRate(true); + assert(gate.Accept(1) && gate.received == 1 && gate.skipped == 0); + for (int rate : {500, 600, 800, 1000}) { + gate = {}; + gate.SetRatePermille(rate); + copies = 0; + int previousCopy = 0; + for (int i = 0; i < 250; ++i) { + gate.SetRatePermille(rate); + const bool accepted = gate.Accept(1 + i*.04); + if (i == 0) assert(accepted); + if (accepted) { + assert(i-previousCopy <= 2); + previousCopy = i; + ++copies; + } + } + assert(copies == 250*rate/1000); + assert(gate.received == 250 && gate.skipped == uint64_t(250-copies)); + assert(gate.Accept(.5)); + } + gate = {}; + for (int rate : {500, 600, 800, 1000, 800, 600, 500}) { + gate.SetRatePermille(rate); + assert(gate.Accept(1 + gate.received*.04)); + } + for (int invalid : {-1, 0, 499, 700, 1001}) { + gate = {}; + gate.SetRatePermille(invalid); + assert(gate.Accept(1)); + assert(!gate.Accept(1.04)); + assert(gate.Accept(1.08)); + } + puts("PASS: fractional stereo copies, stable phase, full-rate setup, source resets, invalid settings and reconnect reset"); +} diff --git a/tools/tests/test_vulkan_pin.py b/tools/tests/test_vulkan_pin.py new file mode 100644 index 0000000000..c848f77f7c --- /dev/null +++ b/tools/tests/test_vulkan_pin.py @@ -0,0 +1,141 @@ +import os +from pathlib import Path +import shutil +import subprocess +import tempfile +import unittest + +SOURCE = Path(__file__).resolve().parents[1] / "linuxfs/fex/vulkanpin.c" +THUNK = r""" +#include +typedef struct { char extensionName[256]; unsigned int specVersion; } VkExtensionProperties; +typedef void (*Function)(void); +static const char *names[] = {"VK_KHR_surface", "VK_KHR_display", "VK_KHR_xlib_surface", "VK_EXT_direct_mode_display", + "VK_KHR_get_display_properties2", "VK_EXT_swapchain_colorspace"}; + +int vkEnumerateInstanceExtensionProperties(const char *layer, unsigned int *count, VkExtensionProperties *properties) +{ + unsigned int total = layer ? 0 : sizeof(names) / sizeof(names[0]); + if (!properties) { + *count = total; + return 0; + } + unsigned int n = *count < total ? *count : total; + for (unsigned int i = 0; i < n; i++) { + memset(&properties[i], 0, sizeof(properties[i])); + strcpy(properties[i].extensionName, names[i]); + properties[i].specVersion = i + 1; + } + *count = n; + return n < total ? 5 : 0; +} + +int vkCreateInstance(void) { return 42; } + +Function vkGetInstanceProcAddr(void *instance, const char *name) +{ + (void)instance; + if (!strcmp(name, "vkEnumerateInstanceExtensionProperties")) + return (Function)vkEnumerateInstanceExtensionProperties; + if (!strcmp(name, "vkCreateInstance")) + return (Function)vkCreateInstance; + if (!strcmp(name, "vkGetInstanceProcAddr")) + return (Function)vkGetInstanceProcAddr; + return 0; +} +""" +GAME = r""" +#include +#include +typedef struct { char extensionName[256]; unsigned int specVersion; } VkExtensionProperties; +typedef void (*Function)(void); +typedef int (*Enumerate)(const char *, unsigned int *, VkExtensionProperties *); +typedef Function (*ProcAddr)(void *, const char *); +#ifdef LINKED +int vkCreateInstance(void); +Function vkGetInstanceProcAddr(void *, const char *); +#endif + +static void list(Enumerate enumerate) +{ + VkExtensionProperties found[8]; + unsigned int count = 0; + int result = enumerate(0, &count, 0); + printf("count %u %d\n", count, result); + enumerate(0, &count, found); + for (unsigned int i = 0; i < count; i++) + printf("%s %u\n", found[i].extensionName, found[i].specVersion); + count = 1; + result = enumerate(0, &count, found); + printf("short %u %d %s\n", count, result, found[0].extensionName); +} + +int main(void) +{ +#ifdef LINKED + ProcAddr proc = vkGetInstanceProcAddr; + printf("linked %d\n", vkCreateInstance()); +#else + void *vulkan = dlopen("libvulkan.so.1", RTLD_NOW | RTLD_LOCAL); + if (!vulkan) + return 1; + ProcAddr proc = (ProcAddr)dlsym(vulkan, "vkGetInstanceProcAddr"); + printf("same handle %d\n", dlopen("libvulkan.so", RTLD_NOW | RTLD_NOLOAD) == vulkan); + printf("create %d\n", ((int (*)(void))dlsym(vulkan, "vkCreateInstance"))()); + list((Enumerate)dlsym(vulkan, "vkEnumerateInstanceExtensionProperties")); +#endif + printf("same proc %d create %d missing %d\n", proc(0, "vkGetInstanceProcAddr") == (Function)proc, + ((int (*)(void))proc(0, "vkCreateInstance"))(), proc(0, "vkNothing") == 0); + list((Enumerate)proc(0, "vkEnumerateInstanceExtensionProperties")); + return 0; +} +""" +LISTED = """count 3 0 +VK_KHR_surface 1 +VK_KHR_xlib_surface 3 +VK_EXT_swapchain_colorspace 6 +short 1 5 VK_KHR_surface +""" + + +@unittest.skipUnless(shutil.which("gcc") and os.uname().machine == "x86_64", "needs gcc on an x86-64 host") +class VulkanPinTest(unittest.TestCase): + def setUp(self): + self.tmp = Path(tempfile.mkdtemp()) + self.addCleanup(shutil.rmtree, self.tmp, ignore_errors=True) + + def gcc(self, *args): + made = subprocess.run(["gcc"] + [str(a) for a in args], capture_output=True, text=True) + self.assertEqual(made.returncode, 0, made.stderr) + + def test_display_extensions_are_hidden_in_front_of_the_thunk(self): + thunk = self.tmp / "usr/lib/libvulkan.so.1" + thunk.parent.mkdir(parents=True) + (self.tmp / "thunk.c").write_text(THUNK) + self.gcc("-shared", "-fPIC", "-Wl,-soname,libvulkan.so.1", "-o", thunk, self.tmp / "thunk.c") + stub = self.tmp / "stub/libvulkan.so.1" + stub.parent.mkdir() + self.gcc("-shared", "-nostdlib", "-Wl,-soname," + str(thunk), "-o", stub, "-x", "c", "/dev/null") + pinned = self.tmp / "pin" + pinned.mkdir() + self.gcc("-shared", "-fPIC", "-O2", "-Wall", "-Wextra", "-Werror", "-fvisibility=hidden", '-DVULKAN_THUNK="%s"' % thunk, + "-Wl,-soname,libvulkan.so.1", "-Wl,-z,nodelete", "-Wl,--no-as-needed", "-o", pinned / "libvulkan.so.1", + SOURCE, stub, "-ldl") + os.symlink("libvulkan.so.1", pinned / "libvulkan.so") + exported = subprocess.run(["nm", "-D", "--defined-only", pinned / "libvulkan.so.1"], capture_output=True, text=True) + self.assertEqual(sorted(line.split()[-1] for line in exported.stdout.splitlines()), + ["vkEnumerateInstanceExtensionProperties", "vkGetInstanceProcAddr"]) + (self.tmp / "game.c").write_text(GAME) + env = dict(os.environ, LD_LIBRARY_PATH=str(pinned)) + self.gcc("-o", self.tmp / "loader", self.tmp / "game.c", "-ldl") + run = subprocess.run([self.tmp / "loader"], capture_output=True, text=True, env=env) + self.assertEqual(run.returncode, 0, run.stderr) + self.assertEqual(run.stdout, "same handle 1\ncreate 42\n" + LISTED + "same proc 1 create 42 missing 1\n" + LISTED) + self.gcc("-DLINKED", "-o", self.tmp / "linked", self.tmp / "game.c", "-L", thunk.parent, "-l:libvulkan.so.1", "-ldl") + run = subprocess.run([self.tmp / "linked"], capture_output=True, text=True, env=env) + self.assertEqual(run.returncode, 0, run.stderr) + self.assertEqual(run.stdout, "linked 42\nsame proc 1 create 42 missing 1\n" + LISTED) + + +if __name__ == "__main__": + unittest.main() diff --git a/tools/tests/test_windows_vr_build.py b/tools/tests/test_windows_vr_build.py index df34f31f55..fa51a169ac 100644 --- a/tools/tests/test_windows_vr_build.py +++ b/tools/tests/test_windows_vr_build.py @@ -26,11 +26,13 @@ class WindowsVrBuildTest(unittest.TestCase): for name, source in vr.CONFIGS.items(): self.write(self.root / source, b'{"name": "current"}\n') self.write(self.out / name, b'{"name": "current"}\n') - for name in vr.LIBRARIES: + for name in vr.LIBRARIES | vr.EXECUTABLES: data = bytearray(64) data[:6] = b'\x7fELF\x02\x01' struct.pack_into('= 0 ) { ++ pthread_mutex_lock(&strmh->cb_mutex); + for ( ; transfer_id < LIBUVC_NUM_TRANSFER_BUFS; transfer_id++) { + free ( strmh->transfers[transfer_id]->buffer ); + libusb_free_transfer ( strmh->transfers[transfer_id]); + strmh->transfers[transfer_id] = 0; + } +- ret = UVC_SUCCESS; ++ pthread_mutex_unlock(&strmh->cb_mutex); ++ uvc_stream_stop(strmh); + } + + UVC_EXIT(ret); + return ret; diff --git a/tools/uvc/submit_failure_test.cpp b/tools/uvc/submit_failure_test.cpp new file mode 100644 index 0000000000..67811908b7 --- /dev/null +++ b/tools/uvc/submit_failure_test.cpp @@ -0,0 +1,112 @@ +#include +#include +#include +#include +#include +#include + +static int failAt; +static int submissions; +static int cancellations; +static bool invalidCancellation; +static std::vector completions; + +extern "C" int __wrap_libusb_submit_transfer(libusb_transfer* transfer) { + if (!transfer) return LIBUSB_ERROR_INVALID_PARAM; + return submissions++ == failAt ? LIBUSB_ERROR_NO_MEM : LIBUSB_SUCCESS; +} + +extern "C" int __wrap_libusb_cancel_transfer(libusb_transfer* transfer) { + if (!transfer) { + invalidCancellation = true; + return LIBUSB_ERROR_INVALID_PARAM; + } + ++cancellations; + completions.emplace_back([transfer] { + transfer->status = LIBUSB_TRANSFER_CANCELLED; + transfer->callback(transfer); + }); + return LIBUSB_SUCCESS; +} + +extern "C" int __wrap_libusb_set_interface_alt_setting(libusb_device_handle*, int, int) { + return LIBUSB_SUCCESS; +} + +extern "C" int __wrap_libusb_get_ss_endpoint_companion_descriptor( + libusb_context*, const libusb_endpoint_descriptor*, libusb_ss_endpoint_companion_descriptor**) { + return LIBUSB_ERROR_NOT_FOUND; +} + +static void onFrame(uvc_frame_t*, void*) {} + +static bool checkFailure(int failureIndex) { + failAt = failureIndex; + submissions = cancellations = 0; + invalidCancellation = false; + uvc_frame_desc_t frame{}; + frame.bFrameIndex = 1; + frame.wWidth = 640; + frame.wHeight = 480; + uvc_format_desc_t format{}; + format.bFormatIndex = 1; + format.frame_descs = &frame; + memcpy(format.guidFormat, "MJPG", 4); + frame.parent = &format; + uvc_streaming_interface_t streamInterface{}; + streamInterface.bInterfaceNumber = 1; + streamInterface.bEndpointAddress = 0x81; + streamInterface.format_descs = &format; + format.parent = &streamInterface; + libusb_endpoint_descriptor endpoint{}; + endpoint.bEndpointAddress = 0x81; + endpoint.bmAttributes = LIBUSB_TRANSFER_TYPE_ISOCHRONOUS; + endpoint.wMaxPacketSize = 512; + libusb_interface_descriptor alternatives[2]{}; + alternatives[0].bInterfaceNumber = alternatives[1].bInterfaceNumber = 1; + alternatives[1].bAlternateSetting = 1; + alternatives[1].bNumEndpoints = 1; + alternatives[1].endpoint = &endpoint; + libusb_interface interfaces[2]{}; + interfaces[1].num_altsetting = 2; + interfaces[1].altsetting = alternatives; + libusb_config_descriptor config{}; + config.bNumInterfaces = 2; + config.interface = interfaces; + uvc_device_info_t info{}; + info.config = &config; + uvc_device_handle_t camera{}; + camera.info = &info; + uvc_stream_handle_t stream{}; + stream.devh = &camera; + stream.stream_if = &streamInterface; + stream.cur_ctrl.bInterfaceNumber = 1; + stream.cur_ctrl.bFormatIndex = 1; + stream.cur_ctrl.bFrameIndex = 1; + stream.cur_ctrl.dwMaxPayloadTransferSize = 512; + stream.cur_ctrl.dwMaxVideoFrameSize = 8192; + pthread_mutex_init(&stream.cb_mutex, nullptr); + pthread_cond_init(&stream.cb_cond, nullptr); + + const int result = uvc_stream_start(&stream, onFrame, nullptr, 0); + if (result == UVC_SUCCESS) uvc_stream_stop(&stream); + for (auto& completion : completions) completion.join(); + completions.clear(); + bool valid = result == (failureIndex < 8 ? LIBUSB_ERROR_NO_MEM : UVC_SUCCESS) + && !stream.running && cancellations == failureIndex && !invalidCancellation; + for (auto* transfer : stream.transfers) valid = valid && transfer == nullptr; + pthread_cond_destroy(&stream.cb_cond); + pthread_mutex_destroy(&stream.cb_mutex); + if (!valid) std::fprintf(stderr, "failureIndex=%d result=%d cancellations=%d\n", failureIndex, result, cancellations); + return valid; +} + +int main() { + for (int iteration = 0; iteration < 20; ++iteration) { + for (int failureIndex : {0, 3, 8}) { + if (!checkFailure(failureIndex)) return 1; + } + } + std::puts("PASS: 60 starts covering zero/partial/full submissions; no USB hardware calls"); + return 0; +} diff --git a/tools/vr/build.sh b/tools/vr/build.sh index a436b39f78..fd8aebd1c5 100755 --- a/tools/vr/build.sh +++ b/tools/vr/build.sh @@ -31,9 +31,31 @@ compile() { cc -std=c11 -O2 -Wall -Wextra -Werror -Ibuild/vr/include -Itools/vr/src \ -o build/vr/test_fence_tracker tools/vr/tests/test_fence_tracker.c build/vr/test_fence_tracker + cc -std=c11 -O2 -Wall -Wextra -Wno-unused-parameter -pthread -Ibuild/vr/include \ + -o build/vr/test_timeline_bridge tools/vr/tests/test_timeline_bridge.c -ldl + build/vr/test_timeline_bridge + cc -std=c11 -O2 -Wall -Wextra -Wno-unused-parameter -pthread -Ibuild/vr/include \ + -o build/vr/test_compositor_submit tools/vr/tests/test_compositor_submit.c -ldl + build/vr/test_compositor_submit c++ -std=c++17 -O2 -Wall -Wextra -Werror -Itools/vr/src \ -o build/vr/test_render_target tools/vr/tests/test_render_target.cpp build/vr/test_render_target + c++ -std=c++17 -O2 -Wall -Wextra -Werror -Ibuild/vr/include -Itools/vr/src \ + -o build/vr/test_presenter_image tools/vr/tests/test_presenter_image.cpp + build/vr/test_presenter_image + c++ -std=c++17 -O2 -Wall -Wextra -Werror -Itools/vr/src \ + -o build/vr/test_spatial_tracking tools/vr/tests/test_spatial_tracking.cpp + build/vr/test_spatial_tracking + c++ -std=c++17 -O2 -Wall -Wextra -Werror -Itools/vr/src \ + -o build/vr/test_adaptive_pose tools/vr/tests/test_adaptive_pose.cpp + build/vr/test_adaptive_pose + c++ -std=c++17 -O2 -Wall -Wextra -Wno-unused-parameter -pthread -Itools/vr/src \ + -o build/vr/test_optical_controller tools/vr/tests/test_optical_controller.cpp + build/vr/test_optical_controller + cc -shared -fPIC -O2 -Wall -Wextra -Werror \ + -o build/vr/libdroiddeck_vr_scheduling.so tools/vr/src/scheduling.c -ldl + cc -O2 -Wall -Wextra -Werror -o build/vr/test_scheduling tools/vr/tests/test_scheduling.c + LD_PRELOAD="$PWD/build/vr/libdroiddeck_vr_scheduling.so" build/vr/test_scheduling c++ -std=c++17 -O2 -Wall -Wextra -Werror -Wno-unused-parameter -Itools/vr/src \ -o build/vr/test_joycon tools/vr/tests/test_joycon.cpp build/vr/test_joycon @@ -58,8 +80,10 @@ compile() { aarch64-linux-gnu-g++ -std=c++17 -shared -fPIC -O2 -Wall -Wextra -Wno-missing-field-initializers -fvisibility=hidden -pthread \ -static-libstdc++ -static-libgcc -Wl,-z,defs -Wl,-z,nodelete -Ibuild/vr/include \ -o build/vr/out/layer/libVkLayer_droiddeck_vr.so build/vr/vk_layer.o tools/vr/src/wsi_capture.cpp -ldl + aarch64-linux-gnu-gcc -shared -fPIC -O2 -Wall -Wextra -Werror -Wl,-z,defs \ + -o build/vr/out/layer/libdroiddeck_vr_scheduling.so tools/vr/src/scheduling.c -ldl aarch64-linux-gnu-strip --strip-unneeded build/vr/out/droiddeck/bin/linuxarm64/driver_droiddeck.so \ - build/vr/out/layer/libVkLayer_droiddeck_vr.so') + build/vr/out/layer/libVkLayer_droiddeck_vr.so build/vr/out/layer/libdroiddeck_vr_scheduling.so') if [ "$native" = 1 ]; then (cd "$repo" && "${cmd[@]}") else diff --git a/tools/vr/build_windows.py b/tools/vr/build_windows.py index 7f79a86a3f..06a1dde74f 100644 --- a/tools/vr/build_windows.py +++ b/tools/vr/build_windows.py @@ -14,18 +14,27 @@ IMAGE = 'droiddeck-local-cross:24.04-v3' MANIFEST = 'vr-build.json' SOURCE_TREES = ('tools/vr/src', 'tools/vr/tests', 'tools/vr/third_party', 'tools/vr/driver_droiddeck', 'tools/vr/layer') -SOURCE_FILES = ('tools/vr/build.sh', 'tools/vr/build_windows.py', 'tools/local-cross.Dockerfile', +SOURCE_FILES = ('tools/vr/build.sh', 'tools/vr/build_windows.py', 'tools/vr/make_hand_models.cpp', 'tools/local-cross.Dockerfile', 'app/src/main/cpp/waylandcomp/src/headpose_shm.h', + 'app/src/main/cpp/waylandcomp/src/spatialpose_shm.h', 'app/src/main/cpp/waylandcomp/generated/xdg-shell-protocol.c', 'app/src/main/cpp/waylandcomp/generated/xdg-shell-client-protocol.h') -LIBRARIES = {'droiddeck/bin/linuxarm64/driver_droiddeck.so', 'layer/libVkLayer_droiddeck_vr.so'} +LIBRARIES = {'droiddeck/bin/linuxarm64/driver_droiddeck.so', 'layer/libVkLayer_droiddeck_vr.so', + 'layer/libdroiddeck_vr_scheduling.so'} CONFIGS = { 'droiddeck/driver.vrdrivermanifest': 'tools/vr/driver_droiddeck/driver.vrdrivermanifest', 'droiddeck/resources/settings/default.vrsettings': 'tools/vr/driver_droiddeck/resources/settings/default.vrsettings', 'layer/VK_LAYER_DROIDDECK_vr.json': 'tools/vr/layer/VK_LAYER_DROIDDECK_vr.json', 'layer/VK_LAYER_DROIDDECK_vr_implicit.json': 'tools/vr/layer/VK_LAYER_DROIDDECK_vr_implicit.json', } -OUTPUTS = LIBRARIES | CONFIGS.keys() +EXECUTABLES = {'droiddeck/bin/linuxarm64/xr-display-mode'} +HAND_MODELS = { + f'droiddeck/resources/rendermodels/droiddeck_hand_{side}/{name}' + for side in ('left', 'right') + for name in (f'droiddeck_hand_{side}.json', 'hand.mtl', 'hand.png', 'hand_open.obj', + 'hand_fist.obj', 'thumb_index_open.obj', 'thumb_index_pinch.obj') +} +OUTPUTS = LIBRARIES | CONFIGS.keys() | EXECUTABLES | HAND_MODELS def is_source(path): @@ -75,12 +84,15 @@ def read_outputs(folder, root): if path.is_symlink() or not path.resolve().is_relative_to(folder.resolve()): raise ValueError('VR output escapes its build directory: ' + name) data = path.read_bytes() - if name in LIBRARIES: + if name in LIBRARIES or name in EXECUTABLES: if (len(data) < 64 or data[:6] != b'\x7fELF\x02\x01' or - struct.unpack_from(' + +namespace droiddeck { + +class AdaptivePositionMotion { +public: + explicit AdaptivePositionMotion(double minimumCutoff = 1.5, double positionGain = 25.0) + : minimumCutoff_(minimumCutoff), positionGain_(positionGain) {} + void Reset() { time_ = 0; velocity_ = {}; } + + void Observe(const Vec3 &position, int64_t time) { + if (time == time_) return; + const double dt = double(time - time_) * 1e-9; + if (time_ > 0 && dt > 0 && dt <= .2) + velocity_ = velocity_ + ((position - position_) * (1.0 / dt) - velocity_) * Alpha(dt, 1.0); + else velocity_ = {}; + position_ = position; time_ = time; + } + + double PositionAlpha(double dt) const { + return Alpha(dt, std::clamp(minimumCutoff_ + positionGain_ * Length(velocity_), minimumCutoff_, 25.0)); + } + +private: + const double minimumCutoff_, positionGain_; + static double Alpha(double dt, double cutoff) { return -std::expm1(-2 * M_PI * cutoff * std::clamp(dt, 0.0, .2)); } + int64_t time_ = 0; + Vec3 position_, velocity_; +}; + +inline Quat ShoulderAim(const Vec3 &head, const Quat &headRotation, const Vec3 &palm, bool right, const Quat &fallback) { + const Vec3 headRight = Rotate(headRotation, {1, 0, 0}); + double yaw = 0; + if (!Heading(headRotation, &yaw)) yaw = std::atan2(-headRight.z, headRight.x); + const Quat torso = AboutY(yaw); + const Vec3 shoulder = head + Rotate(torso, {right ? .18 : -.18, -.28, 0}); + const Vec3 reach = palm - shoulder; + const double distance = Length(reach); + if (!std::isfinite(distance) || distance < .05) return fallback; + const Vec3 forward = Rotate(torso, {0, 0, -1}); + return Normalize(FromTo(forward, reach * (1.0 / distance)) * torso); +} + +} diff --git a/tools/vr/src/driver_droiddeck.cpp b/tools/vr/src/driver_droiddeck.cpp index 76390d3940..771e8da399 100644 --- a/tools/vr/src/driver_droiddeck.cpp +++ b/tools/vr/src/driver_droiddeck.cpp @@ -32,6 +32,8 @@ #include "index_pose.h" #include "joycon_shm.h" #include "presenter.h" +#include "spatial_tracking.h" +#include "luma_joycon.h" #include "render_target.h" #include "xr_tracking_file.h" #include "xr_frame_math.h" @@ -278,7 +280,8 @@ public: const uint32_t create = 0x8 ; for (int i = 0; i < 3; i++) { SharedTextureHandle_t h = 0; - if (!VRIPCResourceManager()->NewSharedVulkanImage(d->nFormat, d->nWidth, d->nHeight, true, false, true, 1, 1, + // Compute access makes SteamVR substitute UNORM for sRGB, darkening direct compositor output. + if (!VRIPCResourceManager()->NewSharedVulkanImage(d->nFormat, d->nWidth, d->nHeight, true, false, false, 1, 1, create, usage, &h)) { Log("NewSharedVulkanImage failed"); return; @@ -529,7 +532,7 @@ bool JoyConLive(const droiddeck_joycon_hand &hand, int64_t nowNs) { class HandController : public ITrackedDeviceServerDriver { public: - explicit HandController(bool right) : right_(right), arm_(right), camera_(right) {} + explicit HandController(bool right) : right_(right), arm_(right), camera_(right), luma_(right) {} EVRInitError Activate(uint32_t id) override { auto props = VRProperties(); @@ -617,12 +620,41 @@ public: } } - bool Update(const droiddeck_joycon_hand *hand, bool bare, const HmdQuaternion_t &headPose, int64_t nowNs) { + bool Update(const droiddeck_joycon_hand *hand, bool bare, const HmdQuaternion_t &headPose, int64_t nowNs, + const droiddeck_spatialpose *spatial = nullptr) { const uint32_t id = id_.load(std::memory_order_acquire); if (id == k_unTrackedDeviceIndexInvalid) return false; const auto now = std::chrono::steady_clock::now(); const double dt = std::min(std::chrono::duration(now - lastUpdate_).count(), 0.1); lastUpdate_ = now; + if (lumaMode_ != (spatial != nullptr) || (spatial && + (lumaConnection_ != spatial->connection || lumaOrigin_ != spatial->origin))) { + Disconnect(id); + luma_.Reset(); + lumaMode_ = spatial != nullptr; + if (spatial) { lumaConnection_ = spatial->connection; lumaOrigin_ = spatial->origin; } + } + if (spatial && !SpatialFresh(spatial->head, nowNs)) { + if (connected_ && hand) { + luma_.Reset(); + lumaSeen_ = false; + DriverPose_t p = GetPose(); + p.poseIsValid = false; + p.result = TrackingResult_Running_OutOfRange; + p.poseTimeOffset = 0; + std::fill_n(p.vecVelocity, 3, 0.0); + std::fill_n(p.vecAngularVelocity, 3, 0.0); + droiddeck_joycon_hand idle{}; + SendInputs(idle, 1.0); + { + std::lock_guard lock(poseMutex_); + pose_ = p; + } + VRServerDriverHost()->TrackedDevicePoseUpdated(id, p, sizeof(p)); + } else Disconnect(id); + LeaveBare(id); + return true; + } if (!hand) { Disconnect(id); if (bare) { @@ -634,6 +666,16 @@ public: } LeaveBare(id); const Quat head{headPose.w, headPose.x, headPose.y, headPose.z}; + if (spatial) { + double norm = 0; + for (float v : hand->rotation) norm += v * v; + if (!std::isfinite(norm) || norm < 0.5 || norm > 1.5 || + !std::all_of(std::begin(hand->angular_velocity), std::end(hand->angular_velocity), + [](float v) { return std::isfinite(v); })) { + Disconnect(id); + return true; + } + } const Quat q = Normalize({hand->rotation[0], hand->rotation[1], hand->rotation[2], hand->rotation[3]}); if (!connected_ || hand->recenter != recenter_) { recenter_ = hand->recenter; @@ -647,41 +689,57 @@ public: arm_.Reset(); follower_.Reset(); kalman_.Reset(); + luma_.Reset(); shown_ = false; Log("%s Joy-Con facing forward", right_ ? "right" : "left"); } const Quat turn = AboutY(yaw_); const Quat aligned = turn * q; const Vec3 rate{hand->angular_velocity[0], hand->angular_velocity[1], hand->angular_velocity[2]}; - const Vec3 palm = arm_.Update(kHeadPosition, head, aligned, Length(rate), dt); - const Vec3 moved = Rotate(turn, {hand->displacement[0], hand->displacement[1], hand->displacement[2]}); - const Vec3 inertial = Rotate(turn, {hand->inertial_velocity[0], hand->inertial_velocity[1], hand->inertial_velocity[2]}); - const bool holding = (hand->buttons & (DROIDDECK_JOYCON_TRIGGER | DROIDDECK_JOYCON_GRIP)) != 0; - kalman_.Input(hand->time_ns - kJoyConDelayNs, inertial, Length(rate)); - const bool camera = kalman_.Ready() && kalman_.TimeNs() - kalman_.SeenNs() <= kCameraHoldNs; - bool switched = false; - if (camera != cameraPlaced_) { - cameraPlaced_ = camera; - switched = true; - Log("%s Joy-Con hand placed by %s", right_ ? "right" : "left", camera ? "the camera" : "the arm model"); - if (!camera && shown_) follower_.Place(shownAt_, moved); - } - const double settle = holding ? kHoldingSettleSeconds : kSettleSeconds; - const Vec3 source = camera ? kalman_.Position() : follower_.Update(palm, moved, dt, settle, kMaxOffset); - const Vec3 velocity = camera ? kalman_.Velocity() : Rotate(turn, {hand->velocity[0], hand->velocity[1], hand->velocity[2]}); - if (shown_ && (switched || Length(source - source_) > kJump)) blend_ = shownAt_ - source; - else if (!shown_) blend_ = Vec3{}; - blend_ = blend_ * std::exp(-dt / kBlendSeconds); - const Vec3 grip = source + blend_; - source_ = source; - shownAt_ = grip; - shown_ = true; - if (FILE *trace = gHandTrace.File()) { - const Vec3 k = kalman_.Ready() ? kalman_.Position() : Vec3{}; - fprintf(trace, "J,%lld,%d,%lld,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%d,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.3f,%.4f,%.4f,%.4f,%u,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%d\n", - (long long)nowNs, right_ ? 1 : 0, (long long)hand->time_ns, moved.x, moved.y, moved.z, palm.x, palm.y, palm.z, - camera ? 1 : 0, k.x, k.y, k.z, grip.x, grip.y, grip.z, Length(rate), velocity.x, velocity.y, velocity.z, - hand->buttons, aligned.w, aligned.x, aligned.y, aligned.z, inertial.x, inertial.y, inertial.z, kalman_.Ready() ? 1 : 0); + Vec3 grip, velocity; + if (spatial) { + const auto tracked = luma_.Update(*spatial, aligned, Length(rate), nowNs, dt); + if (!tracked.valid || aligning_) { + Disconnect(id); + return true; + } + grip = tracked.position; + if (!lumaSeen_ || lumaCamera_ != tracked.camera) { + Log("%s Luma Joy-Con position: %s", right_ ? "right" : "left", + tracked.camera ? "stereo hand" : "6DoF arm estimate"); + lumaSeen_ = true; lumaCamera_ = tracked.camera; + } + } else { + const Vec3 palm = arm_.Update(kHeadPosition, head, aligned, Length(rate), dt); + const Vec3 moved = Rotate(turn, {hand->displacement[0], hand->displacement[1], hand->displacement[2]}); + const Vec3 inertial = Rotate(turn, {hand->inertial_velocity[0], hand->inertial_velocity[1], hand->inertial_velocity[2]}); + const bool holding = (hand->buttons & (DROIDDECK_JOYCON_TRIGGER | DROIDDECK_JOYCON_GRIP)) != 0; + kalman_.Input(hand->time_ns - kJoyConDelayNs, inertial, Length(rate)); + const bool camera = kalman_.Ready() && kalman_.TimeNs() - kalman_.SeenNs() <= kCameraHoldNs; + bool switched = false; + if (camera != cameraPlaced_) { + cameraPlaced_ = camera; + switched = true; + Log("%s Joy-Con hand placed by %s", right_ ? "right" : "left", camera ? "the camera" : "the arm model"); + if (!camera && shown_) follower_.Place(shownAt_, moved); + } + const double settle = holding ? kHoldingSettleSeconds : kSettleSeconds; + const Vec3 source = camera ? kalman_.Position() : follower_.Update(palm, moved, dt, settle, kMaxOffset); + velocity = camera ? kalman_.Velocity() : Rotate(turn, {hand->velocity[0], hand->velocity[1], hand->velocity[2]}); + if (shown_ && (switched || Length(source - source_) > kJump)) blend_ = shownAt_ - source; + else if (!shown_) blend_ = Vec3{}; + blend_ = blend_ * std::exp(-dt / kBlendSeconds); + grip = source + blend_; + source_ = source; + shownAt_ = grip; + shown_ = true; + if (FILE *trace = gHandTrace.File()) { + const Vec3 k = kalman_.Ready() ? kalman_.Position() : Vec3{}; + fprintf(trace, "J,%lld,%d,%lld,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%d,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.3f,%.4f,%.4f,%.4f,%u,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%.4f,%d\n", + (long long)nowNs, right_ ? 1 : 0, (long long)hand->time_ns, moved.x, moved.y, moved.z, palm.x, palm.y, palm.z, + camera ? 1 : 0, k.x, k.y, k.z, grip.x, grip.y, grip.z, Length(rate), velocity.x, velocity.y, velocity.z, + hand->buttons, aligned.w, aligned.x, aligned.y, aligned.z, inertial.x, inertial.y, inertial.z, kalman_.Ready() ? 1 : 0); + } } Quat raw; Vec3 position; @@ -700,7 +758,7 @@ public: p.vecAngularVelocity[0] = spin.x; p.vecAngularVelocity[1] = spin.y; p.vecAngularVelocity[2] = spin.z; - p.poseTimeOffset = -std::max(0.0, (nowNs - hand->time_ns) * 1e-9); + p.poseTimeOffset = spatial ? 0.0 : -std::max(0.0, (nowNs - hand->time_ns) * 1e-9); p.willDriftInYaw = true; p.poseIsValid = true; p.result = TrackingResult_Running_OK; @@ -833,8 +891,10 @@ private: void Disconnect(uint32_t id) { if (!connected_) return; connected_ = false; + lumaSeen_ = false; follower_.Reset(); kalman_.Reset(); + luma_.Reset(); shown_ = false; DriverPose_t p = {}; p.qWorldFromDriverRotation.w = 1; @@ -845,9 +905,9 @@ private: std::lock_guard lock(poseMutex_); pose_ = p; } - VRServerDriverHost()->TrackedDevicePoseUpdated(id, p, sizeof(p)); droiddeck_joycon_hand idle = {}; SendInputs(idle, 1.0); + VRServerDriverHost()->TrackedDevicePoseUpdated(id, p, sizeof(p)); Log("%s Joy-Con hand disconnected", right_ ? "right" : "left"); } @@ -935,6 +995,9 @@ private: HandFollower follower_; HandKalman kalman_; CameraHand camera_; + LumaJoyConPosition luma_; + bool lumaMode_ = false, lumaSeen_ = false, lumaCamera_ = false; + uint64_t lumaConnection_ = 0, lumaOrigin_ = 0; std::atomic bare_{false}, expectBare_{false}; bool bareSeen_ = false; Vec3 source_, shownAt_, blend_; @@ -960,7 +1023,9 @@ private: class CardboardController : public ITrackedDeviceServerDriver { public: - explicit CardboardController(bool right) : right_(right) {} + explicit CardboardController(bool right) : right_(right) { + pose_.qWorldFromDriverRotation.w = pose_.qDriverFromHeadRotation.w = pose_.qRotation.w = 1; + } EVRInitError Activate(uint32_t id) override { id_ = id; @@ -1003,13 +1068,35 @@ public: Log("%s hand activated (%s)", right_ ? "right" : "left", xrMode_ ? "Quest Touch" : "game pad"); return VRInitError_None; } - void Deactivate() override { id_ = k_unTrackedDeviceIndexInvalid; } + void Deactivate() override { ClearInputs(); id_ = k_unTrackedDeviceIndexInvalid; } void EnterStandby() override {} void *GetComponent(const char *) override { return nullptr; } void DebugRequest(const char *, char *resp, uint32_t size) override { if (size) resp[0] = 0; } DriverPose_t GetPose() override { return pose_; } + void ClearInputs() { + const bool optical = opticalActive_; + opticalInputs_.Reset(); + opticalPose_.Reset(); + steadyHandAim_ = false; + opticalActive_ = false; + lastOpticalState_ = ~0u; + if (id_ == k_unTrackedDeviceIndexInvalid) return; + auto in = VRDriverInput(); + EVRInputError error = VRInputError_None; + for (VRInputComponentHandle_t h : {system_, menu_, grip_, triggerClick_, padClick_, padTouch_}) { + const auto result = in->UpdateBooleanComponent(h, false, 0); + if (result != VRInputError_None) error = result; + } + for (VRInputComponentHandle_t h : {trigger_, padX_, padY_}) { + const auto result = in->UpdateScalarComponent(h, 0.0f, 0); + if (result != VRInputError_None) error = result; + } + if (optical || error != VRInputError_None) + Log("%s controller inputs cleared: error=%d", right_ ? "right" : "left", int(error)); + } + void UpdateXr(const DroidDeckXrHand &hand, int64_t predicted) { if (id_ == k_unTrackedDeviceIndexInvalid) return; DriverPose_t pose{}; @@ -1051,6 +1138,7 @@ public: bool XrMode() const { return xrMode_; } void Disconnect() { + ClearInputs(); if (id_ == k_unTrackedDeviceIndexInvalid) return; DriverPose_t p = {}; p.qWorldFromDriverRotation.w = 1; @@ -1059,9 +1147,55 @@ public: p.result = TrackingResult_Uninitialized; pose_ = p; VRServerDriverHost()->TrackedDevicePoseUpdated(id_, p, sizeof(p)); + } + + void UpdateOptical(const dd_spatial_hand &hand, bool headValid, const PadState *pad, int64_t now, + uint64_t connection, uint64_t origin, uint16_t inputEpochs = 0, + const dd_spatial_pose *aimHead = nullptr) { + if (id_ == k_unTrackedDeviceIndexInvalid) return; + opticalActive_ = true; + const bool inputValid = opticalInputs_.Update(hand, headValid, now, connection, origin, inputEpochs); + if (steadyHandAim_ != (aimHead != nullptr)) { + opticalPose_.Reset(); + steadyHandAim_ = aimHead != nullptr; + } + auto visualHand = hand; + if (aimHead && headValid && SpatialFresh(*aimHead, now) && SpatialHandFresh(hand, now)) { + const auto &h = *aimHead; + const auto &p = hand.pose; + const auto q = droiddeck::ShoulderAim({h.position[0], h.position[1], h.position[2]}, + {h.rotation[3], h.rotation[0], h.rotation[1], h.rotation[2]}, + {p.position[0], p.position[1], p.position[2]}, right_, + {p.rotation[3], p.rotation[0], p.rotation[1], p.rotation[2]}); + visualHand.pose.rotation[0] = q.x; visualHand.pose.rotation[1] = q.y; + visualHand.pose.rotation[2] = q.z; visualHand.pose.rotation[3] = q.w; + } + const bool valid = opticalPose_.Update(visualHand, headValid, now, connection, origin); + DriverPose_t p{}; + p.qWorldFromDriverRotation.w = p.qDriverFromHeadRotation.w = p.qRotation.w = 1; + if (valid) { + const auto &observed = opticalPose_.rendered; + p.qRotation = {observed.rotation[3], observed.rotation[0], observed.rotation[1], observed.rotation[2]}; + for (int i=0; i<3; ++i) p.vecPosition[i] = observed.position[i]; + p.poseTimeOffset = double(observed.time_ns-now)/1e9; + } + p.deviceIsConnected = true; p.poseIsValid = valid; + p.result = valid ? TrackingResult_Running_OK : TrackingResult_Running_OutOfRange; auto in = VRDriverInput(); - for (VRInputComponentHandle_t h : {system_, menu_, grip_, triggerClick_, padClick_, padTouch_}) in->UpdateBooleanComponent(h, false, 0); - for (VRInputComponentHandle_t h : {trigger_, padX_, padY_}) in->UpdateScalarComponent(h, 0.0f, 0); + const uint32_t b = pad ? pad->buttons : 0; + in->UpdateBooleanComponent(system_, right_ && (b & PAD_GUIDE), 0); + in->UpdateBooleanComponent(menu_, (b & (right_ ? PAD_START : PAD_SELECT)) != 0, 0); + const auto gripError = in->UpdateBooleanComponent(grip_, opticalInputs_.grip, 0); + const auto clickError = in->UpdateBooleanComponent(triggerClick_, opticalInputs_.click, 0); + const auto triggerError = in->UpdateScalarComponent(trigger_, opticalInputs_.trigger, 0); + const float x = pad ? pad->axes[right_ ? 2 : 0]/32767.0f : 0; + const float y = pad ? -pad->axes[right_ ? 3 : 1]/32767.0f : 0; + in->UpdateScalarComponent(padX_, x, 0); in->UpdateScalarComponent(padY_, y, 0); + in->UpdateBooleanComponent(padTouch_, x*x+y*y > 0.01f || (b & (right_ ? PAD_A : PAD_X)), 0); + in->UpdateBooleanComponent(padClick_, (b & (right_ ? (PAD_A|PAD_R3) : PAD_X)) != 0, 0); + LogOpticalInputs(hand, inputValid, valid, now, connection, origin, inputEpochs, gripError, clickError, triggerError); + pose_ = p; + VRServerDriverHost()->TrackedDevicePoseUpdated(id_, p, sizeof(p)); } static constexpr float kReachSpeed = 0.6f, kReachMin = -0.2f, kReachMax = 1.0f; @@ -1070,8 +1204,10 @@ public: return pad.axes[right ? 4 : 5] > kGrabTrigger || (pad.buttons & (right ? PAD_RB : PAD_LB)); } - void Update(const HmdQuaternion_t &head, const PadState *pad, bool sticksMoveHands, float reach) { + void Update(const DriverPose_t &headPose, const PadState *pad, bool sticksMoveHands, float reach) { + const auto &head = headPose.qRotation; if (id_ == k_unTrackedDeviceIndexInvalid) return; + if (opticalActive_) ClearInputs(); const auto now = std::chrono::steady_clock::now(); const float dt = std::min(std::chrono::duration(now - lastUpdate_).count(), 0.1f); lastUpdate_ = now; @@ -1105,7 +1241,7 @@ public: m[0][0] = 1 - 2 * (y * y + z * z); m[0][1] = 2 * (x * y - z * w); m[0][2] = 2 * (x * z + y * w); m[1][0] = 2 * (x * y + z * w); m[1][1] = 1 - 2 * (x * x + z * z); m[1][2] = 2 * (y * z - x * w); m[2][0] = 2 * (x * z - y * w); m[2][1] = 2 * (y * z + x * w); m[2][2] = 1 - 2 * (x * x + y * y); - for (int i = 0; i < 3; i++) p.vecPosition[i] = (i == 1 ? 1.6 : 0.0) + m[i][0] * off[0] + m[i][1] * off[1] + m[i][2] * off[2]; + for (int i = 0; i < 3; i++) p.vecPosition[i] = headPose.vecPosition[i] + m[i][0] * off[0] + m[i][1] * off[1] + m[i][2] * off[2]; p.poseIsValid = true; p.result = TrackingResult_Running_OK; p.deviceIsConnected = true; @@ -1128,6 +1264,36 @@ public: } private: + void LogOpticalInputs(const dd_spatial_hand &hand, bool inputValid, bool poseValid, int64_t now, + uint64_t connection, uint64_t origin, uint16_t inputEpochs, EVRInputError gripError, + EVRInputError clickError, EVRInputError triggerError) { + const uint32_t triggerBand = !std::isfinite(hand.trigger) ? 3 : hand.trigger < .25f ? 0 : hand.trigger > .65f ? 2 : 1; + const uint32_t state = uint32_t(poseValid) | uint32_t(inputValid)<<1 | uint32_t(opticalInputs_.click)<<2 | + uint32_t(opticalInputs_.grip)<<3 | uint32_t(opticalInputs_.armed)<<4 | uint32_t(opticalInputs_.gripArmed)<<5 | + (hand.pose.flags & 7u)<<6 | triggerBand<<9 | uint32_t(hand.grip != 0)<<11; + const int errors[] = {int(gripError),int(clickError),int(triggerError)}; + if (state == lastOpticalState_ && connection == lastOpticalConnection_ && origin == lastOpticalOrigin_ && + inputEpochs == lastOpticalEpochs_ && + std::equal(errors,errors+3,lastOpticalErrors_)) return; + lastOpticalState_ = state; lastOpticalConnection_ = connection; lastOpticalOrigin_ = origin; + lastOpticalEpochs_ = inputEpochs; + std::copy_n(errors,3,lastOpticalErrors_); + Log("%s optical input pose=%d input=%d flags=%u raw=%.3f/%u out=%.3f/%d/%d armed=%d/%d error=%d/%d/%d ageMs=%.1f connection=%llu origin=%llu epochs=%u/%u", + right_ ? "right" : "left", int(poseValid), int(inputValid), hand.pose.flags, double(hand.trigger), hand.grip, + double(opticalInputs_.trigger), int(opticalInputs_.click), int(opticalInputs_.grip), + int(opticalInputs_.armed), int(opticalInputs_.gripArmed), errors[0], errors[1], errors[2], + hand.pose.time_ns > 0 ? double(now-hand.pose.time_ns)/1e6 : -1., + static_cast(connection), static_cast(origin), + unsigned(inputEpochs & 255), unsigned(inputEpochs >> 8)); + } + OpticalInputs opticalInputs_; + OpticalPose opticalPose_; + bool steadyHandAim_ = false; + bool opticalActive_ = false; + uint32_t lastOpticalState_ = ~0u; + uint64_t lastOpticalConnection_ = 0, lastOpticalOrigin_ = 0; + uint16_t lastOpticalEpochs_ = 0; + int lastOpticalErrors_[3]{}; static constexpr int16_t kGrabTrigger = 153; static constexpr float kStickDeadzone = 0.12f, kHandRangeX = 0.40f, kHandRangeUp = 0.50f, kHandRangeDown = 0.30f, kHandSmoothing = 0.05f, kHandPivot = 0.45f; bool right_; @@ -1244,7 +1410,10 @@ public: void DebugRequest(const char *, char *resp, uint32_t size) override { if (size) resp[0] = 0; } - DriverPose_t GetPose() override { + DriverPose_t GetPose() override { return GetPose(nullptr); } + + DriverPose_t GetPose(droiddeck_spatialpose *snapshot) { + std::lock_guard lock(spatialMutex_); DriverPose_t p = {}; p.qWorldFromDriverRotation.w = 1; p.qDriverFromHeadRotation.w = 1; @@ -1274,6 +1443,26 @@ public: p.poseIsValid = true; p.result = TrackingResult_Running_OK; p.deviceIsConnected = true; + droiddeck_spatialpose spatial{}; + const bool spatialRead = spatial_.Read(&spatial); + if (spatialRead) lastSpatialSnapshot_ = spatial; + else { + spatial = lastSpatialSnapshot_; + spatial.head.flags = 0; + for (auto &hand : spatial.hands) hand.pose.flags = 0; + } + if (snapshot) *snapshot = spatial; + if (spatial.flags & DD_SPATIAL_ACTIVE) { + if (SpatialFresh(spatial.head, SpatialNow())) { + for (int i=0; i<3; ++i) p.vecPosition[i] = spatial.head.position[i]; + p.qRotation = {spatial.head.rotation[3], spatial.head.rotation[0], spatial.head.rotation[1], spatial.head.rotation[2]}; + lastSpatial_ = p; + } else { + if (lastSpatial_.deviceIsConnected) p = lastSpatial_; + p.poseIsValid = false; + p.result = TrackingResult_Running_OutOfRange; + } + } return p; } @@ -1383,7 +1572,7 @@ private: haveJoyCons = true; } const bool joyConsChanged = haveJoyCons && joyCons.seq != lastJoyConSeq_; - if ((fresh || padChanged || joyConsChanged || now - lastSent > std::chrono::milliseconds(100)) && id_ != k_unTrackedDeviceIndexInvalid) { + if ((fresh || padChanged || joyConsChanged || now - lastSent > std::chrono::milliseconds(10)) && id_ != k_unTrackedDeviceIndexInvalid) { if (joyConsChanged) lastJoyConSeq_ = joyCons.seq; if (fresh) { lastSeq = hp.seq; @@ -1400,9 +1589,12 @@ private: Log("headset %s (Cardboard mode %s)", worn ? "worn" : "taken off", worn ? "on" : "off"); } } - DriverPose_t head = GetPose(); + droiddeck_spatialpose spatial{}; + DriverPose_t head = GetPose(&spatial); VRServerDriverHost()->TrackedDevicePoseUpdated(id_, head, sizeof(DriverPose_t)); - if (havePad && (pad.buttons & PAD_L3) && !(lastPad_.buttons & PAD_L3)) { + const bool lumaJoyCons = (spatial.flags & DD_SPATIAL_ACTIVE) && (spatial.flags & DD_SPATIAL_JOYCONS); + const bool optical = !lumaJoyCons && (spatial.flags & DD_SPATIAL_ACTIVE) && (spatial.flags & DD_SPATIAL_HANDS); + if (!optical && havePad && (pad.buttons & PAD_L3) && !(lastPad_.buttons & PAD_L3)) { sticksMoveHands_ = !sticksMoveHands_; Log("sticks now move %s", sticksMoveHands_ ? "the hands" : "in the game"); } @@ -1429,31 +1621,36 @@ private: const bool running = (cam.flags & DROIDDECK_HANDCAM_RUNNING) != 0; if (cam.frame != lastCamFrame_) { lastCamFrame_ = cam.frame; - if (running && std::llabs(nowNs - cam.time_ns) < kHandCamStaleNs) SeeCamera(cam, nowNs); + if (!lumaJoyCons && !optical && running && std::llabs(nowNs - cam.time_ns) < kHandCamStaleNs) SeeCamera(cam, nowNs); } bareFlag_ = running && (cam.flags & DROIDDECK_HANDCAM_BARE_HANDS); bareTimeNs_ = cam.time_ns; } - const bool bare = bareFlag_ && std::llabs(nowNs - bareTimeNs_) < kBareHandsStaleNs; + const bool bare = !otherControllers_ && !optical && !lumaJoyCons && bareFlag_ && std::llabs(nowNs - bareTimeNs_) < kBareHandsStaleNs; if (bare != bareHands_) { bareHands_ = bare; Log("%s", bare ? "no controllers: the camera tracks bare hands" : "camera bare hands off"); } for (int side = 0; side < 2; side++) { const droiddeck_joycon_hand *joyCon = - haveJoyCons && JoyConLive(joyCons.hands[side], nowNs) ? &joyCons.hands[side] : nullptr; + !otherControllers_ && !optical && haveJoyCons && JoyConLive(joyCons.hands[side], nowNs) ? &joyCons.hands[side] : nullptr; if (handControllers_[side]) handControllers_[side]->ExpectBare(!joyCon && bare); if (joyCon || bare) wantHand_[side] = true; - const bool covered = handControllers_[side] && handControllers_[side]->Update(joyCon, bare, head.qRotation, nowNs); + const bool covered = handControllers_[side] && handControllers_[side]->Update(joyCon, bare, head.qRotation, nowNs, + lumaJoyCons ? &spatial : nullptr); CardboardController *hand = hands_[side]; if (!hand) continue; - if (otherControllers_ || covered || bare) { + if (otherControllers_ || covered || bare || lumaJoyCons) { if (!padHandOff_[side]) hand->Disconnect(); padHandOff_[side] = true; continue; } padHandOff_[side] = false; - hand->Update(head.qRotation, havePad ? &pad : nullptr, sticksMoveHands_, reach_); + if (optical) hand->UpdateOptical(spatial.hands[side], SpatialFresh(spatial.head, SpatialNow()), + havePad ? &pad : nullptr, SpatialNow(), spatial.connection, spatial.origin, + uint16_t(spatial.input_epochs >> (side*16)), + spatial.flags & DD_SPATIAL_STEADY_AIM ? &spatial.head : nullptr); + else hand->Update(head, havePad ? &pad : nullptr, sticksMoveHands_, reach_); } if (havePad) lastPad_ = pad; lastSent = now; @@ -1521,6 +1718,10 @@ public: private: PoseFile pose_; + SpatialFile spatial_; + std::mutex spatialMutex_; + DriverPose_t lastSpatial_{}; + droiddeck_spatialpose lastSpatialSnapshot_{}; XrTrackingFile xr_; XrChaperoneOrigin chaperone_; bool xrMode_ = false; diff --git a/tools/vr/src/luma_joycon.h b/tools/vr/src/luma_joycon.h new file mode 100644 index 0000000000..887fbdd876 --- /dev/null +++ b/tools/vr/src/luma_joycon.h @@ -0,0 +1,67 @@ +#pragma once +#include "arm_model.h" +#include "spatial_tracking.h" + +namespace droiddeck { + +struct LumaJoyConPose { + Vec3 position; + bool valid = false, camera = false; +}; + +class LumaJoyConPosition { +public: + explicit LumaJoyConPosition(bool right) : side_(right ? 1 : 0), arm_(right) {} + + void Reset() { arm_.Reset(); motion_.Reset(); shown_ = false; blend_ = {}; lastCamera_ = {}; } + + LumaJoyConPose Update(const droiddeck_spatialpose &spatial, const Quat &rotation, + double angularSpeed, int64_t now, double dt) { + if (!(spatial.flags & DD_SPATIAL_ACTIVE) || !(spatial.flags & DD_SPATIAL_JOYCONS) || + !SpatialFresh(spatial.head, now)) { + Reset(); + return {}; + } + if (connection_ != spatial.connection || origin_ != spatial.origin) { + Reset(); + connection_ = spatial.connection; origin_ = spatial.origin; + } + dt = std::clamp(dt, 0.0, 0.1); + const auto &h = spatial.head; + const Vec3 head{h.position[0], h.position[1], h.position[2]}; + const Quat headRotation{h.rotation[3], h.rotation[0], h.rotation[1], h.rotation[2]}; + const Vec3 estimate = arm_.Update(head, headRotation, rotation, angularSpeed, dt); + const auto &observation = spatial.hands[side_]; + const auto &p = observation.pose.position; + const Vec3 measured{p[0], p[1], p[2]}; + if (SpatialHandFresh(observation, now) && Length(measured - head) <= 1.5 && + observation.pose.time_ns > lastCamera_.time_ns) { + motion_.Observe(measured, observation.pose.time_ns); + lastCamera_ = observation.pose; + } + const bool camera = SpatialFresh(lastCamera_, now, 200000000LL); + if (camera) { + const Vec3 source{lastCamera_.position[0], lastCamera_.position[1], lastCamera_.position[2]}; + position_ = shown_ ? position_ + (source - position_) * motion_.PositionAlpha(dt) : source; + blend_ = {}; + } else { + motion_.Reset(); + if (shown_ && camera_) blend_ = position_ - estimate; + blend_ = blend_ * std::exp(-dt / .18); + position_ = estimate + blend_; + } + shown_ = true; camera_ = camera; + return {position_, true, camera}; + } + +private: + const int side_; + ArmModel arm_; + AdaptivePositionMotion motion_; + uint64_t connection_ = 0, origin_ = 0; + bool shown_ = false, camera_ = false; + Vec3 position_, blend_; + dd_spatial_pose lastCamera_{}; +}; + +} diff --git a/tools/vr/src/presenter.cpp b/tools/vr/src/presenter.cpp index e8c15bcba8..20b0ad63cd 100644 --- a/tools/vr/src/presenter.cpp +++ b/tools/vr/src/presenter.cpp @@ -10,6 +10,7 @@ typedef unsigned long VisualID; #include "../../../app/src/main/cpp/waylandcomp/src/headpose_shm.h" #include "presenter.h" +#include "presenter_image.h" #include "present_sync.h" #include "xr_tracking_file.h" #include "xr_frame_channel.h" @@ -107,6 +108,7 @@ struct Imported { VkDeviceMemory memory = VK_NULL_HANDLE; uint32_t width = 0, height = 0; uint32_t producerPid = 0; + VkFormat format = VK_FORMAT_UNDEFINED; }; struct PendingImport { @@ -133,14 +135,6 @@ private: bool gpuComplete_ = true; }; -VkFormat UnormOf(uint32_t f) { - switch (f) { - case VK_FORMAT_R8G8B8A8_SRGB: return VK_FORMAT_R8G8B8A8_UNORM; - case VK_FORMAT_B8G8R8A8_SRGB: return VK_FORMAT_B8G8R8A8_UNORM; - default: return (VkFormat)f; - } -} - class Impl { public: static Impl &Get() { @@ -276,7 +270,9 @@ private: } else if (f.texture[0] && !frameChannel_) { std::this_thread::sleep_until(at + guard_); } - if (f.texture[0] && wayland_) FollowPanel(); + if (!frameChannel_) { + if (const Imported *eye = Find(f.texture[0])) FollowPanel(eye->format); + } if (f.texture[0] && (frameChannel_ ? Capture(f) : Draw(f))) shown++; { std::lock_guard lock(mutex_); @@ -335,12 +331,13 @@ private: return false; } - void FollowPanel() { - uint32_t w = 0, h = 0; - if (!PanelSize(&w, &h)) return; + void FollowPanel(VkFormat eyeFormat) { + uint32_t w = width_, h = height_; + if (wayland_ && !PanelSize(&w, &h)) return; const bool resized = w != width_ || h != height_; + const bool encodingChanged = SrgbEyeFormat(eyeFormat) != SrgbEyeFormat(eyeFormat_); const auto now = std::chrono::steady_clock::now(); - if (!resized && (swapchain_ || now < retryAt_)) return; + if (!resized && !encodingChanged && (swapchain_ || now < retryAt_)) return; vk_.DeviceWaitIdle(dev_); if (swapchain_) vk_.DestroySwapchainKHR(dev_, swapchain_, nullptr); swapchain_ = VK_NULL_HANDLE; @@ -348,6 +345,7 @@ private: if (resized) Log("presenter: panel now %ux%u (was %ux%u)", w, h, width_, height_); width_ = w; height_ = h; + eyeFormat_ = eyeFormat; if (!CreateSwapchain()) retryAt_ = now + std::chrono::seconds(1); } @@ -539,7 +537,6 @@ private: VkSemaphoreCreateInfo semci = {VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO, nullptr, 0}; vk_.CreateSemaphore(dev_, &semci, nullptr, &acquired_); vk_.CreateSemaphore(dev_, &semci, nullptr, &rendered_); - if (!frameChannel_ && !CreateSwapchain() && !wayland_) return false; Log("presenter: Vulkan on %s, queue family %u", props.deviceName, qfam_); return true; } @@ -551,9 +548,11 @@ private: vk_.GetPhysicalDeviceSurfaceFormatsKHR(pd_, surface_, &nf, nullptr); std::vector fmts(nf); vk_.GetPhysicalDeviceSurfaceFormatsKHR(pd_, surface_, &nf, fmts.data()); - VkSurfaceFormatKHR fmt = fmts.empty() ? VkSurfaceFormatKHR{VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR} : fmts[0]; - for (auto &f : fmts) - if (f.format == VK_FORMAT_B8G8R8A8_UNORM || f.format == VK_FORMAT_R8G8B8A8_UNORM) { fmt = f; break; } + VkSurfaceFormatKHR fmt{}; + if (!EyeSurfaceFormat(eyeFormat_, fmts.data(), nf, &fmt)) { + Log("presenter: no surface format preserves eye format %d", eyeFormat_); + return false; + } uint32_t npm = 0; vk_.GetPhysicalDeviceSurfacePresentModesKHR(pd_, surface_, &npm, nullptr); std::vector pms(npm); @@ -606,17 +605,10 @@ private: im.width = p.width; im.height = p.height; im.producerPid = p.producerPid; - const char *fl = getenv("DROIDDECK_VR_IMPORT_FORMAT_LIST"); - const bool formatList = !fl || strcmp(fl, "0") != 0; - VkFormat formats[2] = {(VkFormat)p.format, UnormOf(p.format)}; - VkImageFormatListCreateInfo list = {VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, nullptr, 2, formats}; - VkExternalMemoryImageCreateInfo ext = {VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, formatList ? &list : nullptr, - VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT}; - VkImageCreateInfo ici = {VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, &ext, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, - UnormOf(p.format), {p.width, p.height, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, - VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, - VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED}; - VkResult r = vk_.CreateImage(dev_, &ici, nullptr, &im.image); + im.format = (VkFormat)p.format; + // Dedicated OPAQUE_FD imports must match SteamVR's exported image description. + SharedEyeImage description(im.format, p.width, p.height); + VkResult r = vk_.CreateImage(dev_, &description.info, nullptr, &im.image); if (r != VK_SUCCESS) { Log("presenter: import image %d", r); close(p.fd); return; } VkMemoryRequirements req; vk_.GetImageMemoryRequirements(dev_, im.image, &req); @@ -632,8 +624,11 @@ private: vk_.DestroyImage(dev_, im.image, nullptr); return; } - if (vk_.BindImageMemory(dev_, im.image, im.memory, 0) != VK_SUCCESS) { - vk_.DestroyImage(dev_, im.image, nullptr); vk_.FreeMemory(dev_, im.memory, nullptr); + r = vk_.BindImageMemory(dev_, im.image, im.memory, 0); + if (r != VK_SUCCESS) { + Log("presenter: bind imported image %d", r); + vk_.DestroyImage(dev_, im.image, nullptr); + vk_.FreeMemory(dev_, im.memory, nullptr); return; } textures_.push_back(im); @@ -798,6 +793,7 @@ private: bool Draw(const EyeFrame &f) { const Imported *eye[2] = {Find(f.texture[0]), Find(f.texture[1])}; if (!eye[0] || !eye[1] || !swapchain_) return false; + if (SrgbEyeFormat(eye[0]->format) != SrgbEyeFormat(eye[1]->format)) return false; vk_.WaitForFences(dev_, 1, &fence_, VK_TRUE, UINT64_MAX); uint32_t idx = 0; VkResult r = vk_.AcquireNextImageKHR(dev_, swapchain_, 100000000ull, acquired_, VK_NULL_HANDLE, &idx); @@ -902,6 +898,7 @@ private: VkFence fence_ = VK_NULL_HANDLE; VkSemaphore acquired_ = VK_NULL_HANDLE, rendered_ = VK_NULL_HANDLE; VkSwapchainKHR swapchain_ = VK_NULL_HANDLE; + VkFormat eyeFormat_ = VK_FORMAT_UNDEFINED; VkExtent2D extent_{}; std::vector images_; std::vector textures_; diff --git a/tools/vr/src/presenter_image.h b/tools/vr/src/presenter_image.h new file mode 100644 index 0000000000..55e542520c --- /dev/null +++ b/tools/vr/src/presenter_image.h @@ -0,0 +1,57 @@ +#pragma once +#include + +namespace droiddeck { + +inline VkFormat AlternateEyeFormat(VkFormat format) { + switch (format) { + case VK_FORMAT_R8G8B8A8_SRGB: return VK_FORMAT_R8G8B8A8_UNORM; + case VK_FORMAT_R8G8B8A8_UNORM: return VK_FORMAT_R8G8B8A8_SRGB; + case VK_FORMAT_B8G8R8A8_SRGB: return VK_FORMAT_B8G8R8A8_UNORM; + case VK_FORMAT_B8G8R8A8_UNORM: return VK_FORMAT_B8G8R8A8_SRGB; + default: return format; + } +} + +inline bool SrgbEyeFormat(VkFormat format) { + return format == VK_FORMAT_R8G8B8A8_SRGB || format == VK_FORMAT_B8G8R8A8_SRGB; +} + +struct SharedEyeImage { + VkFormat formats[2]; + VkImageFormatListCreateInfo list; + VkExternalMemoryImageCreateInfo external; + VkImageCreateInfo info; + + SharedEyeImage(VkFormat format, uint32_t width, uint32_t height) + : formats{format, AlternateEyeFormat(format)}, + list{VK_STRUCTURE_TYPE_IMAGE_FORMAT_LIST_CREATE_INFO, nullptr, formats[0] == formats[1] ? 1u : 2u, formats}, + external{VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO, &list, VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT}, + info{VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, &external, VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT, VK_IMAGE_TYPE_2D, + format, {width, height, 1}, 1, 1, VK_SAMPLE_COUNT_1_BIT, VK_IMAGE_TILING_OPTIMAL, + VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT | VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT, + VK_SHARING_MODE_EXCLUSIVE, 0, nullptr, VK_IMAGE_LAYOUT_UNDEFINED} {} + SharedEyeImage(const SharedEyeImage &) = delete; + SharedEyeImage &operator=(const SharedEyeImage &) = delete; +}; + +inline bool EyeSurfaceFormat(VkFormat eye, const VkSurfaceFormatKHR *formats, uint32_t count, VkSurfaceFormatKHR *out) { + const bool srgb = SrgbEyeFormat(eye); + if (count == 1 && formats[0].format == VK_FORMAT_UNDEFINED) { + *out = {srgb ? VK_FORMAT_B8G8R8A8_SRGB : VK_FORMAT_B8G8R8A8_UNORM, formats[0].colorSpace}; + return out->colorSpace == VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + for (uint32_t i = 0; i < count; i++) { + const auto &f = formats[i]; + if (f.colorSpace != VK_COLOR_SPACE_SRGB_NONLINEAR_KHR) continue; + if (srgb ? SrgbEyeFormat(f.format) : + f.format == VK_FORMAT_R8G8B8A8_UNORM || f.format == VK_FORMAT_B8G8R8A8_UNORM) { + *out = f; + return true; + } + } + return false; +} + +} diff --git a/tools/vr/src/scheduling.c b/tools/vr/src/scheduling.c new file mode 100644 index 0000000000..df89196500 --- /dev/null +++ b/tools/vr/src/scheduling.c @@ -0,0 +1,38 @@ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include + +extern char *program_invocation_short_name; + +static int cannot_schedule_realtime(void) { + struct rlimit priority; + struct __user_cap_header_struct header = {_LINUX_CAPABILITY_VERSION_3, 0}; + struct __user_cap_data_struct caps[2] = {{0}}; + if (getrlimit(RLIMIT_RTPRIO, &priority) || priority.rlim_cur != 0 || + syscall(SYS_capget, &header, caps)) return 0; + return !(caps[CAP_SYS_NICE / 32].effective & (UINT32_C(1) << (CAP_SYS_NICE % 32))); +} + +int setrlimit(__rlimit_resource_t resource, const struct rlimit *limit) { + int (*next)(__rlimit_resource_t, const struct rlimit *) = dlsym(RTLD_NEXT, "setrlimit"); + if (!next) { errno = ENOSYS; return -1; } + const int saved = errno; + if (resource == RLIMIT_RTTIME && + !strcmp(program_invocation_short_name, "vrcompositor") && cannot_schedule_realtime()) { + struct rlimit current; + if (!getrlimit(resource, ¤t) && + (limit->rlim_cur < current.rlim_cur || limit->rlim_max < current.rlim_max)) { + // SDL's failed RTKit fallback leaves a fatal RT budget on Android GPU submissions. + errno = EPERM; + return -1; + } + } + errno = saved; + return next(resource, limit); +} diff --git a/tools/vr/src/spatial_tracking.h b/tools/vr/src/spatial_tracking.h new file mode 100644 index 0000000000..20842c8877 --- /dev/null +++ b/tools/vr/src/spatial_tracking.h @@ -0,0 +1,175 @@ +#pragma once +#include "../../../app/src/main/cpp/waylandcomp/src/spatialpose_shm.h" +#include "adaptive_pose.h" +#include +#include +#include +#include +#include +#include +#include +#include + +inline int64_t SpatialNow() { + timespec t{}; clock_gettime(CLOCK_MONOTONIC, &t); + return int64_t(t.tv_sec)*1000000000LL+t.tv_nsec; +} +inline bool SpatialFresh(const dd_spatial_pose &p, int64_t now, int64_t maxAge = 100000000LL) { + if (!(p.flags & DD_SPATIAL_VALID) || p.time_ns <= 0 || now < p.time_ns || now-p.time_ns > maxAge) return false; + for (float v : p.position) if (!std::isfinite(v)) return false; + float n = 0; + for (float v : p.rotation) { if (!std::isfinite(v)) return false; n += v*v; } + return n > 0.99f && n < 1.01f; +} +inline bool SpatialHandFresh(const dd_spatial_hand &hand, int64_t now) { + return SpatialFresh(hand.pose, now, 200000000LL); +} +struct OpticalPose { + static constexpr int64_t kVisualHoldNs = 350000000LL; + dd_spatial_hand last{}; + dd_spatial_pose filtered{}, rendered{}; + int64_t receivedAt = 0, renderedAt = 0; + float velocity[3]{}; + unsigned observations = 0; + bool predict = false; + uint64_t connection = 0, origin = 0; + void Reset() { + last = {}; filtered = rendered = {}; + receivedAt = renderedAt = 0; + observations = 0; predict = false; std::fill_n(velocity,3,0); + } + bool HoldLastObservation(int64_t now) { + observations = 0; predict = false; receivedAt = 0; renderedAt = now; + if (SpatialFresh(last.pose,now,kVisualHoldNs)) return true; + Reset(); + return false; + } + bool Update(const dd_spatial_hand &hand, bool headValid, int64_t now, uint64_t nextConnection, uint64_t nextOrigin) { + if (!headValid || connection != nextConnection || origin != nextOrigin) Reset(); + connection = nextConnection; origin = nextOrigin; + if (!headValid) return false; + if (!SpatialHandFresh(hand, now) || hand.pose.time_ns < last.pose.time_ns) + return HoldLastObservation(now); + if (!observations && hand.pose.time_ns == last.pose.time_ns) return HoldLastObservation(now); + const bool interpolate = observations > 0 && renderedAt > 0 && now >= renderedAt && SpatialHandFresh(last,now); + if (hand.pose.time_ns > last.pose.time_ns) { + const float dt = float(hand.pose.time_ns-last.pose.time_ns)/1e9f; + if (observations && dt > 0 && dt <= .2f) { + float speed2 = 0, previousSpeed2 = 0, direction = 0, acceleration2 = 0; + for (int i=0; i<3; ++i) { + const float v = (hand.pose.position[i]-last.pose.position[i])/dt; + speed2 += v*v; + previousSpeed2 += velocity[i]*velocity[i]; + direction += v*velocity[i]; + const float acceleration = (v-velocity[i])/dt; + acceleration2 += acceleration*acceleration; + velocity[i] = v; + } + predict = observations >= 2 && speed2 <= 2.25f && acceleration2 <= 36.f && + direction > 0 && direction*direction >= .64f*speed2*previousSpeed2; + } else { + observations = 0; predict = false; std::fill_n(velocity,3,0); + } + filtered = hand.pose; + float norm = 0; + for (float v : filtered.rotation) norm += v*v; + for (float &v : filtered.rotation) v /= std::sqrt(norm); + ++observations; last = hand; receivedAt = now; + } + auto target = filtered; + if (predict) { + // Inference already consumes most capture age; receipt-relative prediction advances between results. + float seconds = std::clamp(float(now-receivedAt)/1e9f,0.f,.08f); + float speed2 = 0; + for (float v : velocity) speed2 += v*v; + if (speed2 > 0) seconds = std::min(seconds,.02f/std::sqrt(speed2)); + for (int i=0; i<3; ++i) target.position[i] += velocity[i]*seconds; + } + if (interpolate) { + const float alpha = 1.f-std::exp(-float(now-renderedAt)/15000000.f); + for (int i=0; i<3; ++i) rendered.position[i] += alpha*(target.position[i]-rendered.position[i]); + float dot = 0, norm = 0; + for (int i=0; i<4; ++i) dot += rendered.rotation[i]*target.rotation[i]; + for (int i=0; i<4; ++i) { + rendered.rotation[i] += alpha*((dot < 0 ? -1 : 1)*target.rotation[i]-rendered.rotation[i]); + norm += rendered.rotation[i]*rendered.rotation[i]; + } + for (float &v : rendered.rotation) v /= std::sqrt(norm); + rendered.time_ns = target.time_ns; rendered.flags = target.flags; + } else rendered = target; + renderedAt = now; + return SpatialHandFresh(last, now); + } +}; +struct OpticalInputs { + bool armed = false, gripArmed = false, click = false, grip = false; + float trigger = 0; + uint64_t connection = 0, origin = 0; + int64_t lastObservation = 0; + uint16_t inputEpochs = 0; + void Release() { armed = gripArmed = click = grip = false; trigger = 0; } + void Reset() { Release(); lastObservation = 0; inputEpochs = 0; } + bool Update(const dd_spatial_hand &hand, bool headValid, int64_t now, uint64_t nextConnection, uint64_t nextOrigin, + uint16_t nextEpochs = 0) { + if (connection != nextConnection || origin != nextOrigin) { + Reset(); connection = nextConnection; origin = nextOrigin; + } + if ((inputEpochs & 0xff) != (nextEpochs & 0xff)) { armed = click = false; trigger = 0; } + if ((inputEpochs >> 8) != (nextEpochs >> 8)) gripArmed = grip = false; + inputEpochs = nextEpochs; + if (!headValid || !SpatialHandFresh(hand, now)) { + Release(); return false; + } + if (hand.pose.time_ns < lastObservation) { Release(); return false; } + const bool newObservation = hand.pose.time_ns > lastObservation; + if (lastObservation && now-lastObservation > 200000000LL) Release(); + const bool triggerValid = (hand.pose.flags & DD_SPATIAL_TRIGGER_VALID) && std::isfinite(hand.trigger) && hand.trigger >= 0 && hand.trigger <= 1; + const bool gripValid = (hand.pose.flags & DD_SPATIAL_GRIP_VALID) && hand.grip <= 1; + if (!triggerValid) { armed = click = false; trigger = 0; } + if (!gripValid) gripArmed = grip = false; + if (!newObservation) return true; + lastObservation = hand.pose.time_ns; + if (triggerValid) { + if (hand.trigger < 0.25f) armed = true; + trigger = armed ? hand.trigger : 0; + click = click ? trigger > 0.45f : trigger > 0.65f; + } + if (gripValid) { + if (!hand.grip) gripArmed = true; + grip = gripArmed && hand.grip; + } + return true; + } +}; +class SpatialFile { +public: + explicit SpatialFile(const char *path = "/run/droiddeck/" DROIDDECK_SPATIALPOSE_FILE) : path_(path) {} + SpatialFile(const SpatialFile &) = delete; + SpatialFile &operator=(const SpatialFile &) = delete; + bool Read(droiddeck_spatialpose *out) { + if (!map_) { + int fd = open(path_, O_RDONLY | O_CLOEXEC); + if (fd < 0) return false; + struct stat st{}; + void *p = MAP_FAILED; + if (fstat(fd, &st) == 0 && st.st_size == sizeof(*out)) + p = mmap(nullptr, sizeof(*out), PROT_READ, MAP_SHARED, fd, 0); + close(fd); + if (p == MAP_FAILED) return false; + map_ = static_cast(p); + } + for (int i = 0; i < 8; ++i) { + const auto seq = __atomic_load_n(&map_->seq, __ATOMIC_ACQUIRE); + if (seq & 1u) continue; + memcpy(out, map_, sizeof(*out)); + __atomic_thread_fence(__ATOMIC_ACQUIRE); + if (seq == __atomic_load_n(&map_->seq, __ATOMIC_RELAXED)) + return out->magic == DROIDDECK_SPATIALPOSE_MAGIC && out->version == DROIDDECK_SPATIALPOSE_VERSION && out->size == sizeof(*out); + } + return false; + } + ~SpatialFile() { if (map_) munmap(map_, sizeof(*map_)); } +private: + const char *path_; + droiddeck_spatialpose *map_ = nullptr; +}; diff --git a/tools/vr/src/vk_layer_droiddeck_vr.c b/tools/vr/src/vk_layer_droiddeck_vr.c index 653d205834..5b315f243b 100644 --- a/tools/vr/src/vk_layer_droiddeck_vr.c +++ b/tools/vr/src/vk_layer_droiddeck_vr.c @@ -969,26 +969,20 @@ static int submit_drop_wait(VkSemaphore s, uint64_t value) { const uint64_t queued = b->submitted; const uint64_t seen_us = b->seen_us; VkDevice dev = b->dev; - _Atomic uint64_t *counter = b->counter; pthread_mutex_unlock(&g_br_lock); if (!value || value <= queued) return 0; struct dev *d = dev_for(dev); if (!d || quest_frames()) return 0; PFN_vkGetSemaphoreCounterValue get = (PFN_vkGetSemaphoreCounterValue)d->gdpa(dev, "vkGetSemaphoreCounterValue"); if (!get) get = (PFN_vkGetSemaphoreCounterValue)d->gdpa(dev, "vkGetSemaphoreCounterValueKHR"); - PFN_vkSignalSemaphore sig = (PFN_vkSignalSemaphore)d->gdpa(dev, "vkSignalSemaphore"); - if (!sig) sig = (PFN_vkSignalSemaphore)d->gdpa(dev, "vkSignalSemaphoreKHR"); if (!get) return 0; const uint64_t start = now_us(); const uint64_t until = start + (start - seen_us > SHARED_IDLE_US ? 0 : SUBMIT_GRACE_US); for (;;) { uint64_t local = 0; if (get(dev, s, &local) == VK_SUCCESS && local >= value) return 0; - uint64_t shared = atomic_load(counter); - if (shared >= value && sig) { - VkSemaphoreSignalInfo si = {VK_STRUCTURE_TYPE_SEMAPHORE_SIGNAL_INFO, NULL, s, shared}; - if (sig(dev, &si) == VK_SUCCESS) return 0; - } + /* Only the poller mirrors shared values. A second host signal here can + * race its signal and submit the same timeline value twice. */ if (now_us() >= until) break; usleep(100); } @@ -1110,11 +1104,7 @@ static void sync_init(void) { say("%s", "frames go to the presenter once their GPU work is done"); } -static struct tracked *track_take(VkQueue q) { - pthread_once(&g_sync_once, sync_init); - if (!g_sync) return NULL; - struct dev *d = dev_for(q); - if (!d) return NULL; +static struct tracked *track_take(struct dev *d) { pthread_mutex_lock(&g_trk_lock); struct tracked *t = track_pool_take(&g_trk, d->handle, d->gdpa); pthread_mutex_unlock(&g_trk_lock); @@ -1138,20 +1128,30 @@ static void track_forget_device(VkDevice dev) { } static VkResult submit_tracked(PFN_vkQueueSubmit next, VkQueue q, uint32_t count, const VkSubmitInfo *submits, VkFence fence) { - struct tracked *slot = track_take(q); - if (!slot) return next(q, count, submits, fence); + if (strcmp(program_invocation_short_name, "vrcompositor")) return next(q, count, submits, fence); + pthread_once(&g_sync_once, sync_init); + struct dev *d = dev_for(q); + if (!g_sync || !d) return next(q, count, submits, fence); + struct tracked *slot = track_take(d); + if (!slot) return VK_ERROR_OUT_OF_HOST_MEMORY; const VkFence mine = slot->fence; VkResult r = next(q, count, submits, fence ? fence : mine); - track_submitted(slot, r == VK_SUCCESS && fence ? next(q, 0, NULL, mine) : r); + if (r == VK_SUCCESS && fence) r = next(q, 0, NULL, mine); + track_submitted(slot, r); return r; } static VkResult submit2_tracked(PFN_vkQueueSubmit2 next, VkQueue q, uint32_t count, const VkSubmitInfo2 *submits, VkFence fence) { - struct tracked *slot = track_take(q); - if (!slot) return next(q, count, submits, fence); + if (strcmp(program_invocation_short_name, "vrcompositor")) return next(q, count, submits, fence); + pthread_once(&g_sync_once, sync_init); + struct dev *d = dev_for(q); + if (!g_sync || !d) return next(q, count, submits, fence); + struct tracked *slot = track_take(d); + if (!slot) return VK_ERROR_OUT_OF_HOST_MEMORY; const VkFence mine = slot->fence; VkResult r = next(q, count, submits, fence ? fence : mine); - track_submitted(slot, r == VK_SUCCESS && fence ? next(q, 0, NULL, mine) : r); + if (r == VK_SUCCESS && fence) r = next(q, 0, NULL, mine); + track_submitted(slot, r); return r; } diff --git a/tools/vr/tests/test_adaptive_pose.cpp b/tools/vr/tests/test_adaptive_pose.cpp new file mode 100644 index 0000000000..8819b09559 --- /dev/null +++ b/tools/vr/tests/test_adaptive_pose.cpp @@ -0,0 +1,58 @@ +#include "adaptive_pose.h" +#include +#include + +using namespace droiddeck; + +int main() { + for (const int period : {10, 20}) { + AdaptivePositionMotion motion; + double position = 0, previous = 0, energy = 0, oldEnergy = 0, target = 0; + for (int frame = 0; frame < 2000; ++frame) { + if (frame % period == 0) { + target = (frame / period % 2 ? 1 : -1) * .004; + motion.Observe({target, 0, 0}, 1000000000LL + frame * 4000000LL); + } + position += (target - position) * motion.PositionAlpha(.004); + previous += (target - previous) * -std::expm1(-.004 / .06); + if (frame > 1000) { energy += position * position; oldEnergy += previous * previous; } + } + assert(energy < oldEnergy * .81); + motion.Reset(); position = previous = 0; + for (int frame = 0; frame < 500; ++frame) { + target = .5 * frame * .004; + motion.Observe({target, 0, 0}, 1000000000LL + frame * 4000000LL); + position += (target - position) * motion.PositionAlpha(.004); + previous += (target - previous) * -std::expm1(-.004 / .06); + } + assert(target - position < target - previous); + assert(target - position < .006); + } + AdaptivePositionMotion motion; + const double idle = motion.PositionAlpha(.01); + motion.Observe({}, 1000000000); + motion.Observe({.1, 0, 0}, 1080000000); + assert(motion.PositionAlpha(.01) > idle); + const double alpha = motion.PositionAlpha(.01); + motion.Observe({9, 9, 9}, 1080000000); + assert(motion.PositionAlpha(.01) == alpha); + motion.Observe({}, 2000000000); + assert(motion.PositionAlpha(.01) == idle); + motion.Reset(); + assert(motion.PositionAlpha(.01) == idle); + assert(motion.PositionAlpha(0) == 0); + for (bool right : {false, true}) for (double yaw : {0., .8, -2.}) { + const Vec3 head{1, 1.6, -2}; + const auto turn = AboutY(yaw); + const Vec3 shoulder = head + Rotate(turn, {right ? .18 : -.18, -.28, 0}); + const Vec3 ray = Rotate(turn, {.2, .1, -.5}); + const auto aim = ShoulderAim(head, turn, shoulder + ray, right, AboutX(1)); + assert(Length(Rotate(aim, {0, 0, -1}) - ray * (1 / Length(ray))) < 1e-8); + const auto flippedPalm = ShoulderAim(head, turn, shoulder + ray, right, AboutX(-2)); + assert(Length(Rotate(flippedPalm, {0, 0, -1}) - Rotate(aim, {0, 0, -1})) < 1e-8); + assert(ShoulderAim(head, turn, shoulder, right, AboutX(1)).x == AboutX(1).x); + } + const auto vertical = ShoulderAim({}, AboutX(M_PI / 2), {.3, -.1, -.5}, true, {}); + assert(std::isfinite(vertical.w) && std::isfinite(vertical.y)); + puts("PASS: adaptive jitter, motion response, capture time, reset, and shoulder aim"); +} diff --git a/tools/vr/tests/test_compositor_submit.c b/tools/vr/tests/test_compositor_submit.c new file mode 100644 index 0000000000..76dd11f82f --- /dev/null +++ b/tools/vr/tests/test_compositor_submit.c @@ -0,0 +1,221 @@ +#define _GNU_SOURCE +#include +#include +#include +#include "../src/vk_layer_droiddeck_vr.c" + +struct fake_fence { VkResult result; unsigned resets; }; +static VkDevice device; +static VkResult submit_result = VK_SUCCESS, completion = VK_SUCCESS, marker_result = VK_SUCCESS; +static unsigned submits_seen, waits_seen, markers_seen, freed; +static int create_fails; +static VkFence caller_fence = (VkFence)(uintptr_t)99; + +static struct fake_fence *fake(VkFence f) { return (struct fake_fence *)(uintptr_t)f; } +static VkResult VKAPI_CALL create(VkDevice d, const VkFenceCreateInfo *ci, const VkAllocationCallbacks *a, VkFence *out) { + assert(d == device && ci->flags == 0); + if (create_fails) return VK_ERROR_OUT_OF_HOST_MEMORY; + struct fake_fence *f = calloc(1, sizeof(*f)); + f->result = VK_TIMEOUT; + *out = (VkFence)(uintptr_t)f; + return VK_SUCCESS; +} +static VkResult VKAPI_CALL wait_fence(VkDevice d, uint32_t n, const VkFence *f, VkBool32 all, uint64_t timeout) { + assert(d == device && n == 1 && all); + assert(timeout == 0); + waits_seen++; + return fake(*f)->result; +} +static VkResult VKAPI_CALL reset(VkDevice d, uint32_t n, const VkFence *f) { + assert(d == device && n == 1); + fake(*f)->resets++; + fake(*f)->result = VK_TIMEOUT; + return VK_SUCCESS; +} +static void VKAPI_CALL destroy(VkDevice d, VkFence f, const VkAllocationCallbacks *a) { + assert(d == device); free(fake(f)); freed++; +} +static PFN_vkVoidFunction VKAPI_CALL gdpa(VkDevice d, const char *name) { + assert(d == device); + if (!strcmp(name, "vkCreateFence")) return (PFN_vkVoidFunction)create; + if (!strcmp(name, "vkWaitForFences")) return (PFN_vkVoidFunction)wait_fence; + if (!strcmp(name, "vkResetFences")) return (PFN_vkVoidFunction)reset; + if (!strcmp(name, "vkDestroyFence")) return (PFN_vkVoidFunction)destroy; + assert(0); return NULL; +} +static VkResult submitted(uint32_t n, VkFence f) { + submits_seen++; + if (!strcmp(program_invocation_short_name, "vrserver")) return submit_result; + assert(g_trk && g_trk->state == TRACK_RESERVED); + if (!n) markers_seen++; + VkResult r = n ? submit_result : marker_result; + if (r == VK_SUCCESS && f != caller_fence) fake(f)->result = completion; + return r; +} +static VkResult VKAPI_CALL submit1(VkQueue q, uint32_t n, const VkSubmitInfo *info, VkFence f) { + assert((n == 0) == (info == NULL)); return submitted(n, f); +} +static VkResult VKAPI_CALL submit2(VkQueue q, uint32_t n, const VkSubmitInfo2 *info, VkFence f) { + assert((n == 0) == (info == NULL)); return submitted(n, f); +} +static void no_init(void) {} + +static VkQueue forwarded_queue; +static const void *forwarded_info; +static VkFence forwarded_fence; +static VkResult VKAPI_CALL forward1(VkQueue q, uint32_t n, const VkSubmitInfo *info, VkFence fence) { + assert(q == forwarded_queue && n == 1 && info == forwarded_info && fence == forwarded_fence); + submits_seen++; + return submit_result; +} +static VkResult VKAPI_CALL forward2(VkQueue q, uint32_t n, const VkSubmitInfo2 *info, VkFence fence) { + assert(q == forwarded_queue && n == 1 && info == forwarded_info && fence == forwarded_fence); + submits_seen++; + return submit_result; +} +static void unavailable_tracking(int modern, int missing_sync, VkFence fence, VkResult result) { + struct droiddeck_present_sync *saved_sync = g_sync; + const uint32_t issued = saved_sync->issued, done = saved_sync->done; + const unsigned freed_before = freed; + uintptr_t unknown_dispatch = 2; + forwarded_queue = missing_sync ? (VkQueue)device : (VkQueue)&unknown_dispatch; + if (missing_sync) g_sync = NULL; + VkSubmitInfo info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO }; + VkSubmitInfo2 info2 = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2 }; + forwarded_info = modern ? (const void *)&info2 : (const void *)&info; + forwarded_fence = fence; + submits_seen = waits_seen = markers_seen = 0; + submit_result = result; + VkResult r = modern ? submit2_tracked(forward2, forwarded_queue, 1, &info2, fence) + : submit_tracked(forward1, forwarded_queue, 1, &info, fence); + assert(r == result && submits_seen == 1 && !waits_seen && !markers_seen && !g_trk); + assert(freed == freed_before && saved_sync->issued == issued && saved_sync->done == done); + g_sync = saved_sync; +} + +static void scenario(int modern, VkFence fence, VkResult submitStatus, VkResult markerStatus, VkResult completeStatus) { + submit_result = submitStatus; marker_result = markerStatus; completion = completeStatus; + submits_seen = waits_seen = markers_seen = 0; + VkSubmitInfo info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO }; + VkSubmitInfo2 info2 = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2 }; + VkResult r = modern ? submit2_tracked(submit2, (VkQueue)device, 1, &info2, fence) + : submit_tracked(submit1, (VkQueue)device, 1, &info, fence); + VkResult tracking = submitStatus == VK_SUCCESS && fence ? markerStatus : submitStatus; + assert(r == tracking); + assert(waits_seen == 0); + assert(markers_seen == (submitStatus == VK_SUCCESS && fence ? 1u : 0u)); + assert(submits_seen == 1 + markers_seen); + if (tracking == VK_SUCCESS) { + assert(g_trk->state == TRACK_SUBMITTED && fake(g_trk->fence)->resets == 0); + if (completeStatus == VK_TIMEOUT) { + uint32_t done; + assert(track_pool_reap(g_trk, g_sync->issued, &done)); + assert(g_trk->state == TRACK_SUBMITTED && fake(g_trk->fence)->resets == 0); + } + fake(g_trk->fence)->result = VK_SUCCESS; + uint32_t done; + assert(!track_pool_reap(g_trk, g_sync->issued, &done)); + } + assert(!track_pool_device_busy(g_trk, device)); + track_pool_forget(&g_trk, device); +} + +static VkFence dependency_fence; +static VkQueue dependency_queue; +static VkResult dependency_submit(VkQueue q, VkFence fence, uint64_t wait, uint64_t signal) { + assert(g_trk && g_trk->state == TRACK_RESERVED); + if (q == dependency_queue) { + assert(wait == 1 && signal == 0 && dependency_fence == VK_NULL_HANDLE); + dependency_fence = fence; + fake(fence)->result = VK_TIMEOUT; + } else { + assert(wait == 0 && signal == 1 && dependency_fence != VK_NULL_HANDLE); + fake(dependency_fence)->result = fake(fence)->result = VK_SUCCESS; + } + return VK_SUCCESS; +} +static VkResult VKAPI_CALL dependent_submit1(VkQueue q, uint32_t n, const VkSubmitInfo *info, VkFence fence) { + assert(n == 1); + const VkTimelineSemaphoreSubmitInfo *timeline = info->pNext; + assert(timeline->sType == VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO); + return dependency_submit(q, fence, info->waitSemaphoreCount ? timeline->pWaitSemaphoreValues[0] : 0, + info->signalSemaphoreCount ? timeline->pSignalSemaphoreValues[0] : 0); +} +static VkResult VKAPI_CALL dependent_submit2(VkQueue q, uint32_t n, const VkSubmitInfo2 *info, VkFence fence) { + assert(n == 1); + return dependency_submit(q, fence, info->waitSemaphoreInfoCount ? info->pWaitSemaphoreInfos[0].value : 0, + info->signalSemaphoreInfoCount ? info->pSignalSemaphoreInfos[0].value : 0); +} +static void wait_before_signal(int modern) { + uintptr_t dispatch = *(uintptr_t *)device; + VkQueue signalling = (VkQueue)&dispatch; + dependency_queue = (VkQueue)device; + dependency_fence = VK_NULL_HANDLE; + VkSemaphore semaphore = (VkSemaphore)(uintptr_t)123; + uint64_t value = 1; + VkPipelineStageFlags stage = VK_PIPELINE_STAGE_ALL_COMMANDS_BIT; + VkTimelineSemaphoreSubmitInfo timeline_wait = { .sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + .waitSemaphoreValueCount = 1, .pWaitSemaphoreValues = &value }; + VkTimelineSemaphoreSubmitInfo timeline_signal = { .sType = VK_STRUCTURE_TYPE_TIMELINE_SEMAPHORE_SUBMIT_INFO, + .signalSemaphoreValueCount = 1, .pSignalSemaphoreValues = &value }; + VkSubmitInfo wait = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .pNext = &timeline_wait, + .waitSemaphoreCount = 1, .pWaitSemaphores = &semaphore, .pWaitDstStageMask = &stage }; + VkSubmitInfo signal = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO, .pNext = &timeline_signal, + .signalSemaphoreCount = 1, .pSignalSemaphores = &semaphore }; + VkSemaphoreSubmitInfo dependency = { .sType = VK_STRUCTURE_TYPE_SEMAPHORE_SUBMIT_INFO, + .semaphore = semaphore, .value = 1, .stageMask = VK_PIPELINE_STAGE_2_ALL_COMMANDS_BIT }; + VkSubmitInfo2 wait2 = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + .waitSemaphoreInfoCount = 1, .pWaitSemaphoreInfos = &dependency }; + VkSubmitInfo2 signal2 = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2, + .signalSemaphoreInfoCount = 1, .pSignalSemaphoreInfos = &dependency }; + assert((modern ? submit2_tracked(dependent_submit2, dependency_queue, 1, &wait2, VK_NULL_HANDLE) + : submit_tracked(dependent_submit1, dependency_queue, 1, &wait, VK_NULL_HANDLE)) == VK_SUCCESS); + uint32_t done; + assert(track_pool_reap(g_trk, g_sync->issued, &done)); + assert(done == g_sync->issued - 1); + assert((modern ? submit2_tracked(dependent_submit2, signalling, 1, &signal2, VK_NULL_HANDLE) + : submit_tracked(dependent_submit1, signalling, 1, &signal, VK_NULL_HANDLE)) == VK_SUCCESS); + assert(!track_pool_reap(g_trk, g_sync->issued, &done)); + assert(done == g_sync->issued); + track_pool_forget(&g_trk, device); +} + +int main(void) { + uintptr_t dispatch = 1; + device = (VkDevice)&dispatch; + g_dev[0] = (struct dev){ .handle = device, .gdpa = gdpa }; + struct droiddeck_present_sync sync = {0}; + g_sync = &sync; + pthread_once(&g_sync_once, no_init); + program_invocation_short_name = "vrcompositor"; + for (int modern = 0; modern < 2; modern++) { + scenario(modern, VK_NULL_HANDLE, VK_SUCCESS, VK_SUCCESS, VK_SUCCESS); + scenario(modern, caller_fence, VK_SUCCESS, VK_SUCCESS, VK_SUCCESS); + scenario(modern, VK_NULL_HANDLE, VK_SUCCESS, VK_SUCCESS, VK_TIMEOUT); + scenario(modern, caller_fence, VK_SUCCESS, VK_SUCCESS, VK_ERROR_DEVICE_LOST); + scenario(modern, caller_fence, VK_ERROR_DEVICE_LOST, VK_SUCCESS, VK_SUCCESS); + scenario(modern, caller_fence, VK_SUCCESS, VK_ERROR_DEVICE_LOST, VK_SUCCESS); + } + assert(freed == 12); + wait_before_signal(0); + wait_before_signal(1); + for (int modern = 0; modern < 2; modern++) { + for (int missing_sync = 0; missing_sync < 2; missing_sync++) { + unavailable_tracking(modern, missing_sync, VK_NULL_HANDLE, VK_SUCCESS); + unavailable_tracking(modern, missing_sync, caller_fence, VK_SUCCESS); + unavailable_tracking(modern, missing_sync, caller_fence, VK_ERROR_DEVICE_LOST); + } + } + create_fails = 1; + submits_seen = 0; + VkSubmitInfo info = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO }; + VkSubmitInfo2 info2 = { .sType = VK_STRUCTURE_TYPE_SUBMIT_INFO_2 }; + assert(submit_tracked(submit1, (VkQueue)device, 1, &info, VK_NULL_HANDLE) == VK_ERROR_OUT_OF_HOST_MEMORY); + assert(submit2_tracked(submit2, (VkQueue)device, 1, &info2, caller_fence) == VK_ERROR_OUT_OF_HOST_MEMORY); + assert(!submits_seen && !g_trk); + program_invocation_short_name = "vrserver"; + submit_result = VK_SUCCESS; waits_seen = 0; + assert(submit_tracked(submit1, (VkQueue)device, 1, &info, caller_fence) == VK_SUCCESS); + assert(submits_seen == 1 && waits_seen == 0 && !g_trk); + puts("PASS: compositor submissions stay asynchronous, preserve caller fences, and allow later cross-queue signals"); +} diff --git a/tools/vr/tests/test_joycon.cpp b/tools/vr/tests/test_joycon.cpp index fabf879949..0308ad78ad 100644 --- a/tools/vr/tests/test_joycon.cpp +++ b/tools/vr/tests/test_joycon.cpp @@ -6,6 +6,7 @@ #include "index_pose.h" #include "handcam_shm.h" #include "joycon_shm.h" +#include "luma_joycon.h" #include #include @@ -516,7 +517,85 @@ static void handCameraLayoutMatchesTheAppWriter() { "camera flags match HandCameraShm.kt"); } +static void lumaStereoFallsBackInTheHeadTrackingOrigin() { + int64_t now = 1000000000; + droiddeck_spatialpose s{}; + s.flags = DD_SPATIAL_ACTIVE | DD_SPATIAL_JOYCONS; + s.connection = s.origin = 1; + s.head = {now, {2, 1.7f, 3}, {0, 0, 0, 1}, DD_SPATIAL_VALID}; + s.hands[0].pose = {now, {1.7f, 1.3f, 2.6f}, {0, 0, 0, 1}, DD_SPATIAL_VALID}; + s.hands[1].pose = {now, {2.3f, 1.3f, 2.6f}, {0, 0, 0, 1}, DD_SPATIAL_VALID}; + LumaJoyConPosition left(false), right(true); + auto l = left.Update(s, {}, 0, now, .01); + auto r = right.Update(s, {}, 0, now, .01); + check(l.valid && l.camera && r.camera && near(l.position.x, 1.7) && near(r.position.x, 2.3), + "stereo positions retain their world coordinates and handedness"); + s.head.position[0] += .1f; + l = left.Update(s, {}, 0, now, .01); + check(near(l.position.x, 1.7), "moving the head does not move a world-space stereo observation"); + now += 200000001; + s.head.time_ns = now; + l = left.Update(s, {}, 0, now, .01); + check(l.valid && !l.camera && Length(l.position - Vec3{1.7, 1.3, 2.6}) < .04, + "stale stereo falls back with a continuous transition"); + for (int i=0; i<100; ++i) l = left.Update(s, {}, 0, now, .01); + ArmModel expected(false); + const auto anchor = expected.Update({2.1, 1.7, 3}, {}, {}, 0, .01); + check(Length(l.position - anchor) < .003, "fallback settles to the translated 6DoF head anchor"); + s.hands[0].pose.time_ns = now; + auto reacquired = left.Update(s, {}, 0, now, .01); + check(reacquired.camera && Length(reacquired.position - l.position) < .04, "reacquisition blends without a snap"); + s.origin++; + s.head.position[0] = 0; + s.hands[0].pose = {}; + l = left.Update(s, {}, 0, now, .01); + check(l.valid && !l.camera && near(l.position.x, -.195), "origin changes discard the old world position and blend"); + s.head.time_ns = now - 100000001; + check(!left.Update(s, {}, 0, now, .01).valid, "head loss invalidates instead of guessing a world origin"); + s.head.time_ns = now; + s.hands[0].pose = {now + 1, {0, 1.3f, 3}, {0,0,0,1}, DD_SPATIAL_VALID}; + check(!left.Update(s, {}, 0, now, .01).camera, "future camera observations are rejected"); + s.hands[0].pose.time_ns = now; + s.hands[0].pose.position[0] = 99; + check(!left.Update(s, {}, 0, now, .01).camera, "implausible hand positions use the arm model"); + s.flags = DD_SPATIAL_ACTIVE; + check(!left.Update(s, {}, 0, now, .01).valid, "the experimental flag is required"); +} + +static void lumaReachSurvivesBriefDetectionMissesWithoutRefreshingOldDepth() { + int64_t now = 1000000000; + droiddeck_spatialpose s{}; + s.flags = DD_SPATIAL_ACTIVE | DD_SPATIAL_JOYCONS; + s.connection = s.origin = 1; + s.head = {now, {0, 1.7f, 0}, {0,0,0,1}, DD_SPATIAL_VALID}; + s.hands[0].pose = {now, {-.2f, 1.3f, -.3f}, {0,0,0,1}, DD_SPATIAL_VALID}; + LumaJoyConPosition tracker(false); + auto pose = tracker.Update(s, {}, 0, now, .01); + s.hands[0] = {}; + for (int i=0; i<19; ++i) { + now += 10000000; s.head.time_ns = now; + pose = tracker.Update(s, {}, 0, now, .01); + check(pose.camera && near(pose.position.z, -.3), "brief misses retain the last measured reach"); + } + now += 20000000; s.head.time_ns = now; + check(!tracker.Update(s, {}, 0, now, .02).camera, "held depth expires at its original capture timestamp"); + for (int i=0; i<100; ++i) { + now += 10000000; s.head.time_ns = now; + if (i % 16 == 0) + s.hands[0].pose = {now - 60000000, {-.2f, 1.3f, -.7f}, {0,0,0,1}, DD_SPATIAL_VALID}; + if (i % 16 == 8) s.hands[0] = {}; + pose = tracker.Update(s, {}, 0, now, .01); + } + check(pose.position.z < -.65, "intermittent stereo observations extend reach instead of repeatedly resetting to the arm model"); + s.connection++; + s.hands[0] = {}; + pose = tracker.Update(s, {}, 0, now, .01); + check(!pose.camera && near(pose.position.z, -.305), "reconnection cannot reuse cached camera depth"); +} + int main() { + lumaReachSurvivesBriefDetectionMissesWithoutRefreshingOldDepth(); + lumaStereoFallsBackInTheHeadTrackingOrigin(); restingHandsHangInFrontAtElbowHeight(); raisingTheControllerExtendsTheArm(); theTorsoOnlyFollowsTheHeadWhileTheControllerMoves(); diff --git a/tools/vr/tests/test_optical_controller.cpp b/tools/vr/tests/test_optical_controller.cpp new file mode 100644 index 0000000000..cd84028830 --- /dev/null +++ b/tools/vr/tests/test_optical_controller.cpp @@ -0,0 +1,263 @@ +#include "../src/driver_droiddeck.cpp" +#include +#include + +void droiddeck::Presenter::AddTextures(const uint64_t[3], const int[3], uint32_t, uint32_t, uint32_t, uint32_t) {} +void droiddeck::Presenter::RemoveTexture(uint64_t) {} +void droiddeck::Presenter::Submit(const EyeFrame &) {} +void droiddeck::Presenter::Shutdown() {} + +struct Host : IVRServerDriverHost { + std::vector poses; + const std::map *inputs = nullptr; + std::vector> inputsAtPose; + bool TrackedDeviceAdded(const char *, ETrackedDeviceClass, ITrackedDeviceServerDriver *) override { return true; } + void TrackedDevicePoseUpdated(uint32_t, const DriverPose_t &p, uint32_t) override { + poses.push_back(p); inputsAtPose.push_back(*inputs); + } + void VsyncEvent(double) override {} + void VendorSpecificEvent(uint32_t, EVREventType, const VREvent_Data_t &, double) override {} + bool IsExiting() override { return false; } + bool PollNextEvent(VREvent_t *, uint32_t) override { return false; } + void GetRawTrackedDevicePoses(float, TrackedDevicePose_t *, uint32_t) override {} + void RequestRestart(const char *, const char *, const char *, const char *) override {} + uint32_t GetFrameTimings(Compositor_FrameTiming *, uint32_t) override { return 0; } + void SetDisplayEyeToHead(uint32_t, const HmdMatrix34_t &, const HmdMatrix34_t &) override {} + void SetDisplayProjectionRaw(uint32_t, const HmdRect2_t &, const HmdRect2_t &) override {} + void SetRecommendedRenderTargetSize(uint32_t, uint32_t, uint32_t) override {} +}; +struct Properties : IVRProperties { + ETrackedPropertyError ReadPropertyBatch(PropertyContainerHandle_t, PropertyRead_t *, uint32_t) override { return TrackedProp_Success; } + ETrackedPropertyError WritePropertyBatch(PropertyContainerHandle_t, PropertyWrite_t *, uint32_t) override { return TrackedProp_Success; } + const char *GetPropErrorNameFromEnum(ETrackedPropertyError) override { return "success"; } + PropertyContainerHandle_t TrackedDeviceToPropertyContainer(TrackedDeviceIndex_t id) override { return id+1; } +}; +struct Input : IVRDriverInput { + std::map values; + std::map handles; + std::map failures; + EVRInputError CreateBooleanComponent(PropertyContainerHandle_t, const char *name, VRInputComponentHandle_t *h) override { + *h = values.size()+1; values[*h]=0; handles[name]=*h; return VRInputError_None; + } + EVRInputError UpdateBooleanComponent(VRInputComponentHandle_t h, bool v, double) override { + if (failures[h] != VRInputError_None) return failures[h]; + values[h]=v; return VRInputError_None; + } + EVRInputError CreateScalarComponent(PropertyContainerHandle_t c, const char *n, VRInputComponentHandle_t *h, EVRScalarType, EVRScalarUnits) override { return CreateBooleanComponent(c,n,h); } + EVRInputError UpdateScalarComponent(VRInputComponentHandle_t h, float v, double) override { + if (failures[h] != VRInputError_None) return failures[h]; + values[h]=v; return VRInputError_None; + } + EVRInputError CreateHapticComponent(PropertyContainerHandle_t c, const char *n, VRInputComponentHandle_t *h) override { return CreateBooleanComponent(c,n,h); } + EVRInputError CreateSkeletonComponent(PropertyContainerHandle_t, const char *, const char *, const char *, EVRSkeletalTrackingLevel, const VRBoneTransform_t *, uint32_t, VRInputComponentHandle_t *) override { return VRInputError_None; } + EVRInputError UpdateSkeletonComponent(VRInputComponentHandle_t, EVRSkeletalMotionRange, const VRBoneTransform_t *, uint32_t) override { return VRInputError_None; } + EVRInputError CreatePoseComponent(PropertyContainerHandle_t, const char *, VRInputComponentHandle_t *) override { return VRInputError_None; } + EVRInputError UpdatePoseComponent(VRInputComponentHandle_t, const HmdMatrix34_t *, double) override { return VRInputError_None; } + EVRInputError CreateEyeTrackingComponent(PropertyContainerHandle_t, const char *, VRInputComponentHandle_t *) override { return VRInputError_None; } + EVRInputError UpdateEyeTrackingComponent(VRInputComponentHandle_t, const VREyeTrackingData_t *, double) override { return VRInputError_None; } +}; +struct DriverLog : IVRDriverLog { + std::vector lines; + void Log(const char *message) override { lines.emplace_back(message); } +}; +struct Context : IVRDriverContext { + Host host; + Input input; + Properties properties; + DriverLog log; + Context() { host.inputs = &input.values; } + void *GetGenericInterface(const char *name, EVRInitError *) override { + if (!strcmp(name, IVRServerDriverHost_Version)) return &host; + if (!strcmp(name, IVRDriverInput_Version)) return &input; + if (!strcmp(name, IVRProperties_Version)) return &properties; + if (!strcmp(name, IVRDriverLog_Version)) return &log; + return nullptr; + } + DriverHandle_t GetDriverHandle() override { return 1; } +}; + +int main() { + Context context; + VRDriverContext() = &context; + CardboardController controller(false); + assert(controller.Activate(1) == VRInitError_None); + const auto gripHandle=context.input.handles.at("/input/grip/click"); + const auto clickHandle=context.input.handles.at("/input/trigger/click"); + const auto triggerHandle=context.input.handles.at("/input/trigger/value"); + const auto assertReleasedAtPose = [&] { + const auto &inputs=context.host.inputsAtPose.back(); + assert(inputs.at(gripHandle)==0 && inputs.at(clickHandle)==0 && inputs.at(triggerHandle)==0); + }; + dd_spatial_hand hand{}; + for (int i=0; i<500; ++i) controller.UpdateOptical(hand, false, nullptr, 1000000000+i, 1, 1); + assert(context.host.poses.size() == 500); + assert(context.log.lines.size()==2); + for (const auto &pose : context.host.poses) { + assert(pose.deviceIsConnected && !pose.poseIsValid); + assert(pose.result == TrackingResult_Running_OutOfRange); + assert(pose.qRotation.w == 1); + } + hand.pose = {1000000000, {1,2,3}, {0,0,0,1}, DD_SPATIAL_VALID | DD_SPATIAL_TRIGGER_VALID | DD_SPATIAL_GRIP_VALID}; + int64_t now=1000000000; + uint64_t connection=1,origin=1; + uint16_t epochs=0; + const auto observe = [&](float trigger,uint32_t grip) { + now+=80000000;hand.pose.time_ns=now;hand.trigger=trigger;hand.grip=grip; + controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs); + }; + const auto missing = [&](bool headValid,int64_t elapsed) { + now+=elapsed;controller.UpdateOptical({},headValid,nullptr,now,connection,origin,epochs); + }; + const auto assertPressed = [&] { + assert(context.host.poses.back().poseIsValid); + assert(context.input.values.at(gripHandle)==1 && context.input.values.at(clickHandle)==1 && + context.input.values.at(triggerHandle)==1); + }; + observe(0,0);observe(1,1);assertPressed(); + now+=200000000;controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs); + assertPressed(); + ++now;controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs); + assert(context.host.poses.back().deviceIsConnected && context.host.poses.back().poseIsValid); + assertReleasedAtPose(); + now=hand.pose.time_ns+350000000;controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs); + assert(context.host.poses.back().poseIsValid); + assert(std::abs(context.host.poses.back().poseTimeOffset+.35)<1e-9); + assertReleasedAtPose(); + ++now;controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs); + assert(context.host.poses.back().deviceIsConnected && !context.host.poses.back().poseIsValid); + assertReleasedAtPose(); + + observe(0,0);observe(1,1);assertPressed(); + missing(true,50000000); + assert(context.host.poses.back().poseIsValid && context.host.poses.back().vecPosition[0]==1); + assert(std::abs(context.host.poses.back().poseTimeOffset+.05)<1e-9); + assertReleasedAtPose(); + missing(true,150000000); + assert(context.host.poses.back().poseIsValid); + assert(std::abs(context.host.poses.back().poseTimeOffset+.2)<1e-9); + missing(true,150000000); + assert(context.host.poses.back().poseIsValid); + assert(std::abs(context.host.poses.back().poseTimeOffset+.35)<1e-9); + assertReleasedAtPose(); + missing(true,1);assert(!context.host.poses.back().poseIsValid); + observe(1,1);assertReleasedAtPose(); + observe(0,0);observe(1,1);assertPressed(); + missing(false,10000000); + assert(!context.host.poses.back().poseIsValid);assertReleasedAtPose(); + missing(true,10000000);assert(!context.host.poses.back().poseIsValid); + + observe(0,0);observe(1,1);assertPressed(); + epochs=1;observe(1,1); + assert(context.host.poses.back().poseIsValid); + assert(context.input.values.at(gripHandle)==1 && context.input.values.at(clickHandle)==0 && context.input.values.at(triggerHandle)==0); + epochs=0x101;observe(1,1);assertReleasedAtPose(); + hand.trigger=0;hand.grip=0; + controller.UpdateOptical(hand,true,nullptr,now+1,connection,origin,epochs); + observe(1,1);assertReleasedAtPose(); + observe(0,0);observe(1,1);assertPressed(); + + ++origin;missing(true,10000000); + assert(!context.host.poses.back().poseIsValid);assertReleasedAtPose(); + observe(1,1);assertReleasedAtPose(); + observe(0,0);observe(1,1);assertPressed(); + ++connection;missing(true,10000000); + assert(!context.host.poses.back().poseIsValid);assertReleasedAtPose(); + + observe(0,0);observe(1,1);assertPressed(); + controller.Disconnect(); + assert(!context.host.poses.back().deviceIsConnected);assertReleasedAtPose(); + missing(true,10000000);assert(!context.host.poses.back().poseIsValid); + observe(1,1);assertReleasedAtPose(); + controller.Update(controller.GetPose(),nullptr,false,0); + missing(true,10000000);assert(!context.host.poses.back().poseIsValid); + PadState pad{};pad.axes[0]=16384;pad.buttons=PAD_SELECT; + controller.UpdateOptical({},true,&pad,++now,connection,origin,epochs); + assert(!context.host.poses.back().poseIsValid); + assert(std::any_of(context.input.values.begin(),context.input.values.end(),[](const auto &v){ return v.second!=0; })); + + observe(0,0);observe(1,1);assertPressed(); + context.input.failures[gripHandle]=VRInputError_IPCError; + missing(false,10000000); + assert(context.input.values.at(gripHandle)==1 && context.input.values.at(triggerHandle)==0); + assert(context.log.lines.back().find("error=7/0/0")!=std::string::npos); + const auto failedLogCount=context.log.lines.size(); + for(int i=0;i<10;++i) missing(false,1); + assert(context.log.lines.size()==failedLogCount); + context.input.failures[gripHandle]=VRInputError_None; + missing(false,10000000); + assertReleasedAtPose(); + assert(context.log.lines.back().find("error=0/0/0")!=std::string::npos); + assert(context.log.lines.size()==failedLogCount+1); + observe(1,1);assertReleasedAtPose(); + observe(0,0);observe(1,1);assertPressed(); + const dd_spatial_pose aimHead{now, {0,1.6f,0}, {0,0,0,1}, DD_SPATIAL_VALID}; + controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs,&aimHead); + assertPressed(); + const auto aimed = controller.GetPose(); + const auto expectedAim = ShoulderAim({0,1.6f,0}, {}, {1,2,3}, false, {}); + assert(std::abs(aimed.qRotation.w - expectedAim.w) < 1e-6); + assert(std::abs(aimed.qRotation.y - expectedAim.y) < 1e-6); + assert(aimed.poseTimeOffset == 0); + controller.UpdateOptical(hand,true,nullptr,now,connection,origin,epochs); + assertPressed(); + assert(controller.GetPose().qRotation.w == 1); + const auto palmRotation=Normalize(AboutX(.4)*AboutY(-.6)); + hand.pose.rotation[0]=palmRotation.x;hand.pose.rotation[1]=palmRotation.y; + hand.pose.rotation[2]=palmRotation.z;hand.pose.rotation[3]=palmRotation.w; + controller.UpdateOptical(hand,true,nullptr,now,connection,++origin,epochs); + const auto normal=controller.GetPose(); + assert(std::abs(normal.qRotation.w-palmRotation.w)<1e-6); + assert(std::abs(normal.qRotation.x-palmRotation.x)<1e-6); + assert(std::abs(normal.qRotation.y-palmRotation.y)<1e-6); + assert(std::abs(normal.qRotation.z-palmRotation.z)<1e-6); + assert(normal.vecPosition[0]==hand.pose.position[0] && normal.poseTimeOffset==0); + controller.UpdateOptical({},true,nullptr,now+1,connection,origin,epochs,&aimHead); + assertReleasedAtPose(); + assert(!controller.GetPose().poseIsValid); + controller.Deactivate(); + for(const auto &value:context.input.values) assert(value.second==0); + const auto poseCount=context.host.poses.size(); + controller.UpdateOptical(hand,true,nullptr,now+1,connection,origin,epochs); + assert(context.host.poses.size()==poseCount); + HandController joyCon(false); + assert(joyCon.Activate(2) == VRInitError_None); + const auto joyTrigger = context.input.handles.at("/input/trigger/click"); + droiddeck_joycon_hand joy{}; + joy.rotation[0] = 1; + joy.time_ns = now; + joy.buttons = DROIDDECK_JOYCON_TRIGGER; + droiddeck_spatialpose spatial{}; + spatial.flags = DD_SPATIAL_ACTIVE | DD_SPATIAL_JOYCONS; + spatial.connection = spatial.origin = 1; + spatial.head = {now, {2, 1.6f, 3}, {0,0,0,1}, DD_SPATIAL_VALID}; + spatial.hands[0].pose = {now, {1.8f, 1.2f, 2.6f}, {0,0,0,1}, DD_SPATIAL_VALID}; + assert(joyCon.Update(&joy, false, {1,0,0,0}, now, &spatial)); + auto pose = joyCon.GetPose(); + assert(pose.poseIsValid && context.input.values.at(joyTrigger) == 1); + Quat expectedRotation; Vec3 expectedPosition; + IndexRawPose(false, {}, {1.8f, 1.2f, 2.6f}, &expectedRotation, &expectedPosition); + assert(std::abs(pose.vecPosition[0] - expectedPosition.x) < 1e-5); + assert(std::abs(pose.qRotation.w - expectedRotation.w) < 1e-5); + spatial.hands[0].pose.flags = 0; + joyCon.Update(&joy, false, {1,0,0,0}, now, &spatial); + assert(joyCon.GetPose().poseIsValid && context.input.values.at(joyTrigger) == 1); + const Quat turned = AboutY(.7); + joy.rotation[0] = turned.w; joy.rotation[2] = turned.y; + joyCon.Update(&joy, false, {1,0,0,0}, now, &spatial); + const auto beforeLoss = joyCon.GetPose().qRotation; + spatial.head.flags = 0; + joyCon.Update(&joy, false, {1,0,0,0}, now, &spatial); + assert(!joyCon.GetPose().poseIsValid && context.input.values.at(joyTrigger) == 0); + assert(context.host.inputsAtPose.back().at(joyTrigger) == 0); + spatial.head.flags = DD_SPATIAL_VALID; + joyCon.Update(&joy, false, {1,0,0,0}, now, &spatial); + assert(std::abs(joyCon.GetPose().qRotation.w - beforeLoss.w) < 1e-5); + assert(std::abs(joyCon.GetPose().qRotation.y - beforeLoss.y) < 1e-5); + spatial.origin++; + spatial.head.position[0] = -2; + joyCon.Update(&joy, false, {1,0,0,0}, now, &spatial); + assert(joyCon.GetPose().poseIsValid && joyCon.GetPose().vecPosition[0] < -2); + joyCon.Update(nullptr, false, {1,0,0,0}, now, &spatial); + assert(!joyCon.GetPose().deviceIsConnected && context.input.values.at(joyTrigger) == 0); + puts("PASS: optical controller recovery and Luma Joy-Con camera, fallback, head loss and origin changes"); +} diff --git a/tools/vr/tests/test_presenter_image.cpp b/tools/vr/tests/test_presenter_image.cpp new file mode 100644 index 0000000000..baf36bddf5 --- /dev/null +++ b/tools/vr/tests/test_presenter_image.cpp @@ -0,0 +1,41 @@ +#include "presenter_image.h" +#include +#include +#include + +int main() { + droiddeck::SharedEyeImage image(VK_FORMAT_R8G8B8A8_SRGB, 1728, 1080); + const auto &info = image.info; + // SteamVR's shared-eye creation trace on the Fold7: format 43, flags 8, usage 0x97, list 43/37. + assert(info.format == 43 && info.flags == 8 && info.usage == 0x97); + assert(info.extent.width == 1728 && info.extent.height == 1080 && info.extent.depth == 1); + assert(info.samples == VK_SAMPLE_COUNT_1_BIT && info.mipLevels == 1 && info.arrayLayers == 1); + assert(info.tiling == VK_IMAGE_TILING_OPTIMAL && info.sharingMode == VK_SHARING_MODE_EXCLUSIVE); + const auto *external = static_cast(info.pNext); + assert(external->handleTypes == VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT); + const auto *list = static_cast(external->pNext); + assert(list->viewFormatCount == 2 && list->pViewFormats[0] == 43 && list->pViewFormats[1] == 37); + + const VkSurfaceFormatKHR choices[] = { + {VK_FORMAT_B8G8R8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_R8G8B8A8_UNORM, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_B8G8R8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + {VK_FORMAT_R8G8B8A8_SRGB, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}, + }; + VkSurfaceFormatKHR selected{}; + for (VkFormat eye : {VK_FORMAT_R8G8B8A8_SRGB, VK_FORMAT_B8G8R8A8_SRGB}) { + assert(droiddeck::EyeSurfaceFormat(eye, choices, 4, &selected)); + assert(droiddeck::SrgbEyeFormat(selected.format)); + assert(!droiddeck::EyeSurfaceFormat(eye, choices, 2, &selected)); + } + for (VkFormat eye : {VK_FORMAT_R8G8B8A8_UNORM, VK_FORMAT_B8G8R8A8_UNORM}) { + assert(droiddeck::EyeSurfaceFormat(eye, choices, 4, &selected)); + assert(!droiddeck::SrgbEyeFormat(selected.format)); + assert(!droiddeck::EyeSurfaceFormat(eye, choices + 2, 2, &selected)); + } + assert(!droiddeck::EyeSurfaceFormat(VK_FORMAT_R8G8B8A8_SRGB, nullptr, 0, &selected)); + const VkSurfaceFormatKHR any{VK_FORMAT_UNDEFINED, VK_COLOR_SPACE_SRGB_NONLINEAR_KHR}; + assert(droiddeck::EyeSurfaceFormat(VK_FORMAT_R8G8B8A8_SRGB, &any, 1, &selected)); + assert(selected.format == VK_FORMAT_B8G8R8A8_SRGB); + std::puts("PASS: shared eye imports match SteamVR and preserve color encoding through presentation"); +} diff --git a/tools/vr/tests/test_scheduling.c b/tools/vr/tests/test_scheduling.c new file mode 100644 index 0000000000..f5ac7592e8 --- /dev/null +++ b/tools/vr/tests/test_scheduling.c @@ -0,0 +1,58 @@ +#define _GNU_SOURCE +#include +#include +#include +#include +#include +#include +#include +#include +#include + +extern char *program_invocation_short_name; + +static int realtime_unavailable(void) { + struct rlimit priority; + struct __user_cap_header_struct header = {_LINUX_CAPABILITY_VERSION_3, 0}; + struct __user_cap_data_struct caps[2] = {{0}}; + assert(getrlimit(RLIMIT_RTPRIO, &priority) == 0); + assert(syscall(SYS_capget, &header, caps) == 0); + return priority.rlim_cur == 0 && + !(caps[CAP_SYS_NICE / 32].effective & (UINT32_C(1) << (CAP_SYS_NICE % 32))); +} + +static void check(int compositor) { + program_invocation_short_name = compositor ? "vrcompositor" : "vrserver"; + struct rlimit before, after, low = {100000, 200000}; + assert(getrlimit(RLIMIT_RTTIME, &before) == 0); + assert(before.rlim_cur > low.rlim_cur && before.rlim_max > low.rlim_max); + const int blocked = compositor && realtime_unavailable(); + int result = setrlimit(RLIMIT_RTTIME, &low); + if (blocked) { + assert(result == -1 && errno == EPERM); + assert(getrlimit(RLIMIT_RTTIME, &after) == 0); + assert(after.rlim_cur == before.rlim_cur && after.rlim_max == before.rlim_max); + assert(setrlimit(RLIMIT_RTTIME, &before) == 0); + } else { + assert(result == 0); + assert(getrlimit(RLIMIT_RTTIME, &after) == 0); + assert(after.rlim_cur == low.rlim_cur && after.rlim_max == low.rlim_max); + } + assert(getrlimit(RLIMIT_NOFILE, &before) == 0); + before.rlim_cur = 64; + assert(setrlimit(RLIMIT_NOFILE, &before) == 0); + assert(getrlimit(RLIMIT_NOFILE, &after) == 0 && after.rlim_cur == 64); + assert(setrlimit(-1, &before) == -1 && errno == EINVAL); +} + +int main(void) { + for (int compositor = 0; compositor <= 1; ++compositor) { + pid_t child = fork(); + assert(child >= 0); + if (!child) { check(compositor); _exit(0); } + int status; + assert(waitpid(child, &status, 0) == child); + assert(WIFEXITED(status) && WEXITSTATUS(status) == 0); + } + puts("SteamVR scheduling regression passed"); +} diff --git a/tools/vr/tests/test_spatial_tracking.cpp b/tools/vr/tests/test_spatial_tracking.cpp new file mode 100644 index 0000000000..4028502419 --- /dev/null +++ b/tools/vr/tests/test_spatial_tracking.cpp @@ -0,0 +1,387 @@ +#include "spatial_tracking.h" +#include +#include +#include +#include + +static float PoseAngle(const float *a, const float *b) { + double dot=0,normA=0,normB=0; + for (int i=0; i<4; ++i) { + dot+=double(a[i])*b[i];normA+=double(a[i])*a[i];normB+=double(b[i])*b[i]; + } + return float(2*std::acos(std::clamp(std::abs(dot)/std::sqrt(normA*normB),0.,1.))); +} + +static void CheckPredictionDirection() { + for (const int framesPerSample : {10,20}) { + OpticalPose pose; + dd_spatial_hand hand{}; + for (int frame=0; frame<2000; ++frame) { + if (frame%framesPerSample==0) { + const int sample=frame/framesPerSample; + const float sign=sample%2 ? -1.f : 1.f; + const float position=sample ? sign*.004f : 0; + const float angle=sample ? sign*.05f : 0; + hand.pose={30000000000LL+frame*4000000LL,{position,0,0}, + {0,sign*std::sin(angle*.5f),0,sign*std::cos(angle*.5f)},DD_SPATIAL_VALID}; + } + assert(pose.Update(hand,true,30060000000LL+frame*4000000LL,1,1)); + assert(!pose.predict); + assert(std::abs(pose.rendered.position[0])<=.004f); + } + } +} + +static void CheckSmallMotion() { + for (const int framesPerSample : {10,20}) { + OpticalPose pose; + dd_spatial_hand hand{}; + const float identity[]={0,0,0,1}; + float previousPosition=0,previousAngle=0; + for (int sample=0; sample<56; ++sample) { + const int step=sample<16 ? 0 : sample<28 ? sample-15 : sample<44 ? 12 : 55-sample; + const float position=step*.0002f,angle=step*.000872665f; + hand.pose={70000000000LL+sample*framesPerSample*4000000LL,{position,0,0}, + {0,std::sin(angle*.5f),0,std::cos(angle*.5f)},DD_SPATIAL_VALID}; + for (int frame=0; frame.00002f); + assert(direction*(PoseAngle(identity,pose.rendered.rotation)-previousAngle)>.00008f); + } + assert(pose.rendered.time_ns==hand.pose.time_ns); + } + const float actualAngle=PoseAngle(identity,pose.rendered.rotation); + assert(std::abs(pose.rendered.position[0]-position)<.0002f); + assert(std::abs(actualAngle-angle)<.00012f); + if ((sample>=16 && sample<28) || sample>=44) { + const float direction=sample<28 ? 1.f : -1.f; + assert(direction*(pose.rendered.position[0]-previousPosition)>.0001f); + assert(direction*(actualAngle-previousAngle)>.0005f); + } + previousPosition=pose.rendered.position[0];previousAngle=actualAngle; + } + } +} + +static void CheckPalmMotion() { + for (const int framesPerSample : {10,20}) { + OpticalPose pose; + dd_spatial_hand hand{}; + const float identity[]={0,0,0,1}; + float maximumPositionError=0,maximumAngleError=0; + for (int frame=0; frame<1000; ++frame) { + if (frame%framesPerSample==0) { + const float elapsed=frame*.004f; + const float angle=elapsed*.1f; + hand.pose={40000000000LL+frame*4000000LL,{elapsed*.01f,0,0}, + {0,std::sin(angle*.5f),0,std::cos(angle*.5f)},DD_SPATIAL_VALID}; + } + assert(pose.Update(hand,true,40060000000LL+frame*4000000LL,1,1)); + if (frame>250) { + const float observedAngle=float(hand.pose.time_ns-40000000000LL)*1e-9f*.1f; + maximumPositionError=std::max(maximumPositionError,std::abs(pose.rendered.position[0]-hand.pose.position[0])); + maximumAngleError=std::max(maximumAngleError,std::abs(PoseAngle(identity,pose.rendered.rotation)-observedAngle)); + } + } + std::printf("Palm %.1fHz slow motion maximum error position=%.3fmm rotation=%.3fdeg\n", + 250./framesPerSample,maximumPositionError*1000,maximumAngleError*180/M_PI); + assert(maximumPositionError<.001f && maximumAngleError<.013f); + pose.Reset(); + hand.pose={50000000000LL,{0,0,0},{0,0,0,1},DD_SPATIAL_VALID}; + for (int frame=0; frame=0 && rendered.position[0]<=.100001f && !pose.predict); + if (positionResponseMs<0 && rendered.position[0]>=.095f) positionResponseMs=frame*4; + if (rotationResponseMs<0 && PoseAngle(identity,rendered.rotation)>=float(M_PI*.475)) + rotationResponseMs=frame*4; + assert(rendered.time_ns==hand.pose.time_ns); + } + assert(positionResponseMs>=36 && positionResponseMs<=52); + assert(rotationResponseMs>=36 && rotationResponseMs<=52); + std::printf("Palm %.1fHz 95%% step response position=%dms rotation=%dms after receipt\n", + 250./framesPerSample,positionResponseMs,rotationResponseMs); + const auto observed=pose.last; + hand.pose.position[0]=2; + hand.pose.rotation[1]=0;hand.pose.rotation[3]=1; + assert(pose.Update(hand,true,hand.pose.time_ns+140000000LL,1,1)); + assert(std::memcmp(&pose.last,&observed,sizeof(observed))==0); + } +} + +static void CheckVisualHold() { + OpticalPose pose; + OpticalInputs input; + dd_spatial_hand hand{}; + for (int sample=0; sample<3; ++sample) { + hand.pose={60000000000LL+sample*80000000LL,{sample*.02f,0,0},{0,0,0,1}, + DD_SPATIAL_VALID|DD_SPATIAL_TRIGGER_VALID|DD_SPATIAL_GRIP_VALID}; + hand.trigger=sample==2 ? 1.f : 0.f;hand.grip=sample==2 ? 1u : 0u; + assert(input.Update(hand,true,hand.pose.time_ns+60000000LL,1,1)); + for (int frame=0; frame<20; ++frame) + assert(pose.Update(hand,true,hand.pose.time_ns+60000000LL+frame*4000000LL,1,1)); + } + assert(pose.predict && input.click && input.grip); + const auto held=pose.rendered; + const int64_t capture=hand.pose.time_ns; + assert(pose.Update({},true,capture+140000000LL,1,1)); + assert(!input.Update({},true,capture+140000000LL,1,1)); + assert(!input.click && !input.grip && input.trigger==0); + assert(!pose.predict && !pose.receivedAt && !pose.observations); + auto repeated=hand;repeated.pose.position[0]=9; + for (int ageMs : {150,200,201,300,350}) { + const int64_t now=capture+ageMs*1000000LL; + assert(pose.Update(repeated,true,now,1,1)); + input.Update(repeated,true,now,1,1); + assert(!input.click && !input.grip && input.trigger==0); + assert(pose.last.pose.time_ns==capture); + assert(std::memcmp(&pose.rendered,&held,sizeof(held))==0); + assert(!pose.predict && !pose.receivedAt && !pose.observations); + } + auto stale=hand;stale.pose.time_ns+=20000000LL;stale.pose.position[0]=5; + assert(pose.Update(stale,true,capture+350000000LL,1,1)); + assert(pose.last.pose.time_ns==capture && std::memcmp(&pose.rendered,&held,sizeof(held))==0); + assert(!pose.Update(stale,true,capture+350000001LL,1,1)); + assert(!pose.last.pose.time_ns && !pose.rendered.flags); + assert(!pose.Update(repeated,true,capture+351000000LL,1,1)); + OpticalPose unseen; + assert(!unseen.Update(stale,true,stale.pose.time_ns+200000001LL,1,1)); + auto fresh=hand;fresh.pose.time_ns=capture+350000000LL;fresh.pose.position[0]=.5f; + fresh.pose.rotation[1]=std::sin(.3f);fresh.pose.rotation[3]=std::cos(.3f); + assert(pose.Update(fresh,true,capture+400000000LL,1,1)); + assert(pose.rendered.position[0]==.5f && !pose.predict); + assert(PoseAngle(pose.rendered.rotation,fresh.pose.rotation)<1e-6f); + assert(pose.rendered.time_ns==fresh.pose.time_ns); + assert(input.Update(fresh,true,capture+400000000LL,1,1)); + assert(!input.click && !input.grip && input.trigger==0); + for (int reset=0; reset<3; ++reset) { + OpticalPose resetPose; + assert(resetPose.Update(hand,true,capture,1,1)); + assert(resetPose.Update({},true,capture+150000000LL,1,1)); + const uint64_t connection=reset==1 ? 2 : 1,origin=reset==2 ? 2 : 1; + assert(!resetPose.Update({},reset!=0,capture+160000000LL,connection,origin)); + assert(!resetPose.last.pose.time_ns && !resetPose.rendered.flags); + assert(!resetPose.Update({},true,capture+170000000LL,connection,origin)); + } +} + +int main() { + CheckPredictionDirection(); + CheckSmallMotion(); + CheckPalmMotion(); + CheckVisualHold(); + static_assert(sizeof(droiddeck_spatialpose) == 176); + static_assert(offsetof(droiddeck_spatialpose, head) == 40); + static_assert(offsetof(droiddeck_spatialpose, hands) == 80); + char path[] = "/tmp/droiddeck-spatial-XXXXXX"; + int fd = mkstemp(path); assert(fd >= 0); + droiddeck_spatialpose out{}, s{}; + s.magic = DROIDDECK_SPATIALPOSE_MAGIC; s.version = DROIDDECK_SPATIALPOSE_VERSION; s.size = sizeof(s); + s.head = {1000000000LL, {1,2,3}, {0,0,0,1}, DD_SPATIAL_VALID}; + s.hands[0].pose = s.head; s.hands[0].pose.time_ns -= 50000000; + { + SpatialFile empty(path); assert(!empty.Read(&out)); + assert(write(fd, &s, sizeof(s)-1) == sizeof(s)-1); assert(!empty.Read(&out)); + } + assert(pwrite(fd, &s, sizeof(s), 0) == sizeof(s)); + { + SpatialFile reader(path); assert(reader.Read(&out)); + assert(out.hands[0].pose.time_ns == 950000000); + s.seq = 1; assert(pwrite(fd, &s, sizeof(s), 0) == sizeof(s)); assert(!reader.Read(&out)); + s.seq = 2; s.version = 99; assert(pwrite(fd, &s, sizeof(s), 0) == sizeof(s)); assert(!reader.Read(&out)); + s.version = 1; assert(pwrite(fd, &s, sizeof(s), 0) == sizeof(s)); assert(!reader.Read(&out)); + s.version = 2; assert(pwrite(fd, &s, sizeof(s), 0) == sizeof(s)); assert(!reader.Read(&out)); + s.input_epochs = 0x04030201; + s.version = DROIDDECK_SPATIALPOSE_VERSION; s.head.time_ns += 90000000; assert(pwrite(fd, &s, sizeof(s), 0) == sizeof(s)); assert(reader.Read(&out)); + assert(SpatialFresh(out.head, 1190000000)); assert(!SpatialFresh(out.head,1190000001)); + assert(out.hands[0].pose.time_ns == 950000000); + assert(out.input_epochs == 0x04030201); + assert(SpatialHandFresh(out.hands[0],1150000000)); assert(!SpatialHandFresh(out.hands[0],1150000001)); + } + close(fd); unlink(path); + assert(!SpatialFresh(s.head,1)); + s.head.position[0] = std::numeric_limits::quiet_NaN(); assert(!SpatialFresh(s.head,1100000000)); + auto hand=s.hands[0]; hand.pose.time_ns=1000000000; hand.trigger=1; hand.grip=1; + hand.pose.flags |= DD_SPATIAL_TRIGGER_VALID | DD_SPATIAL_GRIP_VALID; + OpticalInputs input; + assert(input.Update(hand,true,1000000000,7,1)); assert(!input.click && !input.grip); + auto updateInput = [&](float trigger, uint32_t grip, uint16_t epochs = 0) { + hand.pose.time_ns += 10000000; + hand.trigger=trigger; hand.grip=grip; + return input.Update(hand,true,hand.pose.time_ns,7,1,epochs); + }; + updateInput(0,0); assert(input.armed && input.gripArmed); + updateInput(.8f,1); assert(input.click && input.grip); + updateInput(.5f,1); assert(input.click); + updateInput(.4f,1); assert(!input.click && input.grip); + updateInput(1,1); assert(input.click && input.grip); + assert(input.Update(hand,true,hand.pose.time_ns+200000000,7,1)); assert(input.click && input.grip); + assert(!input.Update(hand,true,hand.pose.time_ns+200000001,7,1)); assert(!input.armed && !input.grip && input.trigger==0); + hand.pose.time_ns += 210000000; + updateInput(1,1); assert(!input.click && !input.grip); + updateInput(0,0); updateInput(1,1); assert(input.click && input.grip); + hand.pose.flags &= ~DD_SPATIAL_TRIGGER_VALID; + updateInput(1,1); assert(!input.armed && !input.click && input.trigger==0 && input.grip); + hand.pose.flags |= DD_SPATIAL_TRIGGER_VALID; + updateInput(1,1); assert(!input.click && input.grip); + updateInput(0,1); updateInput(1,1); assert(input.click); + hand.pose.flags &= ~DD_SPATIAL_GRIP_VALID; + updateInput(1,1); assert(input.click && !input.grip && !input.gripArmed); + hand.pose.flags |= DD_SPATIAL_GRIP_VALID; + updateInput(1,1); assert(input.click && !input.grip); + updateInput(1,0); updateInput(1,1); assert(input.grip); + + updateInput(1,1,0x0100); assert(input.click && !input.grip && !input.gripArmed); + updateInput(1,1,0x0100); assert(input.click && !input.grip); + updateInput(1,0,0x0100); updateInput(1,1,0x0100); assert(input.grip); + updateInput(1,1,0x0101); assert(!input.click && !input.armed && input.grip); + updateInput(0,1,0x0101); updateInput(1,1,0x0101); assert(input.click && input.grip); + updateInput(1,1,0x0202); assert(!input.click && !input.grip); + updateInput(0,0,0x0202); updateInput(1,1,0x0202); assert(input.click && input.grip); + + input.Update({},false,hand.pose.time_ns+1,7,1,0x0202); + hand.trigger=0; hand.grip=0; + input.Update(hand,true,hand.pose.time_ns+2,7,1,0x0202); assert(!input.armed && !input.gripArmed); + updateInput(1,1,0x0202); assert(!input.click && !input.grip); + updateInput(0,0,0x0202); updateInput(1,1,0x0202); assert(input.click && input.grip); + hand.pose.time_ns+=210000000; + updateInput(1,1,0x0202); assert(!input.click && !input.grip); + updateInput(0,0,0x0202); updateInput(1,1,0x0202); + auto backwards=hand; backwards.pose.time_ns-=1000000; backwards.trigger=0; backwards.grip=0; + assert(!input.Update(backwards,true,hand.pose.time_ns,7,1,0x0202)); assert(!input.armed && !input.gripArmed); + updateInput(0,0,0x0202); updateInput(1,1,0x0202); + input.Update(hand,true,hand.pose.time_ns,7,2,0x0202); assert(!input.click && !input.grip); + hand.pose.time_ns=1210000000; + + OpticalPose pose; + assert(pose.Update(hand,true,1210000000,7,2)); + auto corrupt = hand; corrupt.pose.position[0] = std::numeric_limits::quiet_NaN(); + assert(pose.Update(corrupt,true,1220000000,7,2)); + assert(pose.last.pose.position[0] == hand.pose.position[0]); + auto future = hand; future.pose.time_ns = 1500000000; + assert(pose.Update(future,true,1230000000,7,2)); + assert(pose.last.pose.time_ns == 1210000000); + auto old = hand; old.pose.time_ns -= 10000000; old.pose.position[0] = 99; + assert(pose.Update(old,true,1240000000,7,2)); + assert(pose.last.pose.time_ns == 1210000000); + assert(pose.Update({},true,1410000000,7,2)); + assert(pose.Update({},true,1560000000,7,2)); + assert(!pose.Update({},true,1560000001,7,2)); + + for (const int64_t delay : {60000000LL, 80000000LL, 120000000LL}) { + pose.Reset(); + hand.pose = {2000000000LL, {0,0,0}, {0,0,0,1.002f}, DD_SPATIAL_VALID}; + float previous = 0; + for (int sample=0; sample<8; ++sample) { + hand.pose.time_ns = 2000000000LL+sample*80000000LL; + hand.pose.position[0] = sample*.02f; + const float sign = sample%2 ? -1.f : 1.f; + hand.pose.rotation[1] = sign*1.002f*std::sin(sample*.05f); + hand.pose.rotation[3] = sign*1.002f*std::cos(sample*.05f); + float midway = 0; + for (int frame=0; frame<20; ++frame) { + const int64_t now = hand.pose.time_ns+delay+frame*4000000LL; + assert(pose.Update(hand,true,now,7,3)); + assert(pose.receivedAt==hand.pose.time_ns+delay); + assert(pose.rendered.time_ns==hand.pose.time_ns); + assert(pose.rendered.position[0]<=hand.pose.position[0]+.020001f); + float norm=0; for(float v:pose.rendered.rotation) norm+=v*v; + assert(std::abs(norm-1)<1e-5); + if (sample>=4) { + assert(pose.predict); + assert(pose.rendered.position[0]>previous+.0005f); + assert(pose.rendered.position[0]=4 && frame==19) assert(pose.rendered.position[0]-midway>.005f); + previous = pose.rendered.position[0]; + } + } + const int64_t stoppedAt = hand.pose.time_ns+80000000; + const float beforeStop = pose.rendered.position[0]; + hand.pose.time_ns = stoppedAt; + for (int frame=0; frame<20; ++frame) { + assert(pose.Update(hand,true,stoppedAt+delay+frame*4000000LL,7,3)); + assert(pose.rendered.position[0]<=beforeStop); + assert(pose.rendered.position[0]>=hand.pose.position[0]); + } + assert(std::abs(pose.rendered.position[0]-hand.pose.position[0])<.0001f); + + hand.pose.time_ns+=80000000; hand.pose.position[0]-=.04f; + previous = pose.rendered.position[0]; + for (int frame=0; frame<20; ++frame) { + assert(pose.Update(hand,true,hand.pose.time_ns+delay+frame*4000000LL,7,3)); + assert(!pose.predict); + assert(pose.rendered.position[0]<=previous); + assert(pose.rendered.position[0]>=hand.pose.position[0]); + previous=pose.rendered.position[0]; + } + hand.pose.time_ns+=80000000; hand.pose.position[0]-=.04f; + pose.Update(hand,true,hand.pose.time_ns+delay,7,3); + assert(pose.predict); + for (int frame=1; frame<20; ++frame) { + pose.Update(hand,true,hand.pose.time_ns+delay+frame*4000000LL,7,3); + assert(pose.rendered.position[0]>=hand.pose.position[0]-.020001f); + } + hand.pose.time_ns+=80000000; hand.pose.position[0]+=1.f; + pose.Update(hand,true,hand.pose.time_ns+delay,7,3); + assert(!pose.predict); + for (int frame=1; frame<20; ++frame) { + pose.Update(hand,true,hand.pose.time_ns+delay+frame*4000000LL,7,3); + assert(pose.rendered.position[0]<=hand.pose.position[0]); + } + } + + const auto held = pose.rendered; + pose.Update({},true,hand.pose.time_ns+196000000,7,3); + assert(!pose.predict && !pose.receivedAt); + assert(std::memcmp(&pose.rendered,&held,sizeof(held))==0); + pose.Update(hand,true,hand.pose.time_ns+198000000,7,3); + assert(std::memcmp(&pose.rendered,&held,sizeof(held))==0); + assert(pose.Update({},true,hand.pose.time_ns+200000000,7,3)); + assert(pose.Update({},true,hand.pose.time_ns+350000000,7,3)); + assert(!pose.Update({},true,hand.pose.time_ns+350000001,7,3)); + hand.pose.time_ns+=400000000; hand.pose.position[0]=.5f; + pose.Update(hand,true,hand.pose.time_ns+60000000,7,3); + assert(pose.rendered.position[0]==.5f && !pose.predict); + hand.pose.time_ns+=80000000; hand.pose.position[0]=.6f; + pose.Update(hand,true,hand.pose.time_ns+60000000,7,4); + assert(pose.rendered.position[0]==.6f && !pose.predict); + hand.pose.time_ns+=80000000; hand.pose.position[0]=.7f; + pose.Update(hand,true,hand.pose.time_ns+60000000,8,4); + assert(pose.rendered.position[0]==.7f && !pose.predict); + pose.Update({},false,hand.pose.time_ns+64000000,8,4); + assert(!pose.last.pose.time_ns && !pose.receivedAt && !pose.predict); + + pose.Reset(); + const int64_t delays[] = {60000000,120000000,80000000,60000000,120000000,80000000}; + int sample=0; + hand.pose = {6000000000LL, {0,0,0}, {0,0,0,1}, DD_SPATIAL_VALID}; + float previous=0; + for (int64_t now=6060000000LL; now<6556000000LL; now+=4000000) { + if (sample<5 && now>=6000000000LL+(sample+1)*80000000LL+delays[sample+1]) { + ++sample; + hand.pose.time_ns=6000000000LL+sample*80000000LL; + hand.pose.position[0]=sample*.02f; + } + assert(pose.Update(hand,true,now,8,4)); + assert(pose.receivedAt==hand.pose.time_ns+delays[sample]); + assert(pose.rendered.position[0]>=previous); + assert(pose.rendered.position[0]<=previous+.01f); + assert(pose.rendered.position[0]<=hand.pose.position[0]+.020001f); + assert(pose.rendered.time_ns==hand.pose.time_ns); + previous=pose.rendered.position[0]; + } + puts("PASS: spatial layout, files, freshness, independent timestamps and optical input recovery"); +} diff --git a/tools/vr/tests/test_timeline_bridge.c b/tools/vr/tests/test_timeline_bridge.c new file mode 100644 index 0000000000..3e23324d7c --- /dev/null +++ b/tools/vr/tests/test_timeline_bridge.c @@ -0,0 +1,63 @@ +#define _GNU_SOURCE +#include +#include +#include + +#include "../src/vk_layer_droiddeck_vr.c" + +static _Atomic uint64_t local_value; +static _Atomic unsigned duplicate_signals; +static pthread_t submit_thread; +static int first_read = 1; + +static VkResult VKAPI_CALL get_value(VkDevice device, VkSemaphore semaphore, uint64_t *value) { + (void)device; + (void)semaphore; + *value = atomic_load(&local_value); + if (pthread_equal(pthread_self(), submit_thread) && first_read) { + first_read = 0; + assert(pthread_create(&g_poller, NULL, poller, NULL) == 0); + const uint64_t until = now_us() + 2000000; + while (!atomic_load(&local_value) && now_us() < until) usleep(100); + assert(atomic_load(&local_value) == 1); + } + return VK_SUCCESS; +} + +static VkResult VKAPI_CALL signal_value(VkDevice device, const VkSemaphoreSignalInfo *info) { + (void)device; + if (info->value <= atomic_load(&local_value)) { + atomic_fetch_add(&duplicate_signals, 1); + return VK_ERROR_DEVICE_LOST; + } + atomic_store(&local_value, info->value); + return VK_SUCCESS; +} + +static PFN_vkVoidFunction VKAPI_CALL get_proc(VkDevice device, const char *name) { + (void)device; + if (!strcmp(name, "vkGetSemaphoreCounterValue")) return (PFN_vkVoidFunction)get_value; + if (!strcmp(name, "vkSignalSemaphore")) return (PFN_vkVoidFunction)signal_value; + assert(0); + return NULL; +} + +int main(void) { + uintptr_t dispatch = 1; + VkDevice device = (VkDevice)&dispatch; + VkSemaphore semaphore = (VkSemaphore)(uintptr_t)2; + _Atomic uint64_t shared = 1; + g_dev[0] = (struct dev){.handle = device, .gdpa = get_proc}; + g_br[0] = (struct bridged){.sem = semaphore, .dev = device, .counter = &shared, + .fd = -1, .timeline = 1, .seen = 1, .seen_us = now_us(), .imported = 1}; + submit_thread = pthread_self(); + + submit_drop_wait(semaphore, 1); + assert(atomic_load(&local_value) == 1); + assert(atomic_load(&duplicate_signals) == 0); + assert(submit_drop_wait(semaphore, 1) == 0); + pthread_cancel(g_poller); + pthread_join(g_poller, NULL); + puts("PASS: a concurrent bridge signal cannot be repeated by the submit thread"); + return 0; +}