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