mirror of
https://github.com/Droid-Deck/DroidDeck.git
synced 2026-11-22 06:15:58 +00:00
Add VITURE glasses support: hardware control, 3D, head tracking
Glasses get their own controller over the MCU (permission, 120 Hz default, brightness, volume, sunblock, 2D/3D) and the game moves onto them when plugged in. The IMU drives Cardboard head tracking and the SteamVR driver. 3D falls back to one eye's view on phones that can't send the 3840x1080 signal. Options open from a glasses button in game and on the Steam page.
This commit is contained in:
1 parent
31d12a9f6c
commit
1e66ff17c1
37 files changed
+2624
-318
No files matched your search
@@ -0,0 +1,111 @@
|
||||
package com.droiddeck.launcher.glasses
|
||||
|
||||
import org.junit.Assert.assertArrayEquals
|
||||
import org.junit.Assert.assertEquals
|
||||
import org.junit.Assert.assertFalse
|
||||
import org.junit.Assert.assertNotNull
|
||||
import org.junit.Assert.assertNull
|
||||
import org.junit.Assert.assertTrue
|
||||
import org.junit.Test
|
||||
import java.nio.ByteBuffer
|
||||
import kotlin.math.cos
|
||||
import kotlin.math.sin
|
||||
|
||||
class VitureProtocolTest {
|
||||
private fun u8(b: Byte) = b.toInt() and 0xFF
|
||||
private fun u16(b: ByteArray, at: Int) = u8(b[at]) or (u8(b[at + 1]) shl 8)
|
||||
|
||||
@Test fun crcIsXmodem() {
|
||||
val check = "123456789".toByteArray()
|
||||
assertEquals(0x31C3, VitureProtocol.crc16(check, 0, check.size))
|
||||
}
|
||||
|
||||
@Test fun packetLayout() {
|
||||
val p = VitureProtocol.packet(VitureProtocol.MSG_BRIGHTNESS, byteArrayOf(5, 0))
|
||||
assertEquals(VitureProtocol.PACKET_SIZE, p.size)
|
||||
assertEquals(0xFF, u8(p[0]))
|
||||
assertEquals(VitureProtocol.MAGIC_COMMAND, u8(p[1]))
|
||||
assertEquals(2 + 0x0C, u16(p, 4))
|
||||
assertEquals(VitureProtocol.MSG_BRIGHTNESS, u16(p, 14))
|
||||
assertEquals(5, u8(p[18]))
|
||||
assertEquals(VitureProtocol.crc16(p, 4, u16(p, 4) + 2), u16(p, 2))
|
||||
for (i in 6 until 14) assertEquals(0, u8(p[i]))
|
||||
}
|
||||
|
||||
@Test fun parseRoundTripsAndChecksCrc() {
|
||||
val p = VitureProtocol.packet(VitureProtocol.MSG_DISPLAY, byteArrayOf(0x34))
|
||||
val f = VitureProtocol.parse(p, p.size)
|
||||
assertNotNull(f)
|
||||
assertEquals(VitureProtocol.MAGIC_COMMAND, f!!.magic)
|
||||
assertEquals(VitureProtocol.MSG_DISPLAY, f.msgId)
|
||||
assertArrayEquals(byteArrayOf(0x34), f.payload)
|
||||
assertTrue(f.crcOk)
|
||||
p[18] = 0x31
|
||||
assertFalse(VitureProtocol.parse(p, p.size)!!.crcOk)
|
||||
}
|
||||
|
||||
@Test fun parseReadsRepliesAndRejectsJunk() {
|
||||
val reply = VitureProtocol.packet(VitureProtocol.MSG_GET_VOLUME, byteArrayOf(0, 5))
|
||||
reply[1] = VitureProtocol.MAGIC_REPORT.toByte()
|
||||
val f = VitureProtocol.parse(reply, reply.size)!!
|
||||
assertEquals(VitureProtocol.MAGIC_REPORT, f.magic)
|
||||
assertArrayEquals(byteArrayOf(0, 5), f.payload)
|
||||
assertNull(VitureProtocol.parse(ByteArray(64), 64))
|
||||
assertNull(VitureProtocol.parse(reply, 8))
|
||||
val wrongMagic = reply.copyOf().also { it[1] = 0x10 }
|
||||
assertNull(VitureProtocol.parse(wrongMagic, wrongMagic.size))
|
||||
}
|
||||
|
||||
@Test fun modelsAndModes() {
|
||||
val pro = VitureProtocol.model(0x101d, "VITURE Pro XR Glasses")!!
|
||||
assertEquals("VITURE Pro XR", pro.name)
|
||||
assertEquals(VitureProtocol.Family.PRO, pro.family)
|
||||
assertTrue(pro.controllable)
|
||||
assertFalse(pro.sbs90)
|
||||
assertEquals(0x34, pro.mode(120, false))
|
||||
assertEquals(0x33, pro.mode(90, false))
|
||||
assertEquals(0x31, pro.mode(60, false))
|
||||
assertEquals(0x32, pro.mode(90, true))
|
||||
assertEquals(0x32, pro.mode(60, true))
|
||||
|
||||
val luma = VitureProtocol.model(0x1131, null)!!
|
||||
assertEquals("VITURE Luma", luma.name)
|
||||
assertTrue(luma.sbs90)
|
||||
assertEquals(0x44, luma.mode(120, false))
|
||||
assertEquals(0x45, luma.mode(90, true))
|
||||
assertEquals(0x42, luma.mode(60, true))
|
||||
|
||||
assertFalse(VitureProtocol.model(0x1201, null)!!.controllable)
|
||||
assertNull(VitureProtocol.model(0x9999, "VITURE"))
|
||||
assertEquals("VITURE One", VitureProtocol.model(0x1011, "Something else")!!.name)
|
||||
}
|
||||
|
||||
@Test fun modeHelpers() {
|
||||
listOf(0x32, 0x35, 0x42, 0x45).forEach { assertTrue(VitureProtocol.modeIsSbs(it)) }
|
||||
listOf(0x31, 0x33, 0x34, 0x41, 0x44).forEach { assertFalse(VitureProtocol.modeIsSbs(it)) }
|
||||
assertEquals(120, VitureProtocol.modeHz(0x34))
|
||||
assertEquals(90, VitureProtocol.modeHz(0x35))
|
||||
assertEquals(60, VitureProtocol.modeHz(0x32))
|
||||
}
|
||||
|
||||
@Test fun imuPrefersTheQuaternion() {
|
||||
val half = Math.toRadians(30.0) / 2
|
||||
val payload = ByteBuffer.allocate(40)
|
||||
.putFloat(1f).putFloat(2f).putFloat(3f)
|
||||
.putFloat(0f).putFloat(0f)
|
||||
.putFloat(cos(half).toFloat()).putFloat(0f).putFloat(0f).putFloat(sin(half).toFloat())
|
||||
.array()
|
||||
val q = VitureProtocol.imuQuaternion(payload)!!
|
||||
assertArrayEquals(floatArrayOf(0f, 0f, sin(half).toFloat(), cos(half).toFloat()), q, 1e-5f)
|
||||
}
|
||||
|
||||
@Test fun imuFallsBackToEuler() {
|
||||
val payload = ByteBuffer.allocate(12).putFloat(0f).putFloat(0f).putFloat(30f).array()
|
||||
val q = VitureProtocol.imuQuaternion(payload)!!
|
||||
val half = Math.toRadians(30.0) / 2
|
||||
assertArrayEquals(floatArrayOf(0f, 0f, sin(half).toFloat(), cos(half).toFloat()), q, 1e-5f)
|
||||
assertNull(VitureProtocol.imuQuaternion(ByteArray(8)))
|
||||
val nan = ByteBuffer.allocate(12).putFloat(Float.NaN).putFloat(0f).putFloat(0f).array()
|
||||
assertNull(VitureProtocol.imuQuaternion(nan))
|
||||
}
|
||||
}
|
||||
@@ -174,4 +174,37 @@ class CardboardTest {
|
||||
assertVec(HeadPose.apply(r, floatArrayOf(0f, 1f, 0f)), HeadPose.apply(s270, floatArrayOf(1f, 0f, 0f)))
|
||||
assertVec(r, HeadPose.toScreen(HeadPose.toScreen(HeadPose.toScreen(HeadPose.toScreen(r, 1), 1), 1), 1))
|
||||
}
|
||||
|
||||
@Test fun glassesLevelAndAheadIsStraightAhead() {
|
||||
val s2w = HeadPose.fromGlasses(0f, 0f, 0f, 1f)
|
||||
assertVec(floatArrayOf(1f, 0f, 0f), HeadPose.apply(s2w, floatArrayOf(0f, 0f, -1f)))
|
||||
assertVec(floatArrayOf(0f, 0f, 1f), HeadPose.apply(s2w, floatArrayOf(0f, 1f, 0f)))
|
||||
assertVec(HeadPose.IDENTITY, HeadPose.relative(HeadPose.recenter(s2w), s2w))
|
||||
}
|
||||
|
||||
@Test fun glassesTurnedLeftLookLeft() {
|
||||
val ref = HeadPose.recenter(HeadPose.fromGlasses(0f, 0f, 0f, 1f))
|
||||
val q = quat(0f, 0f, 1f, 30.0)
|
||||
val view = HeadPose.relative(ref, HeadPose.fromGlasses(q[0], q[1], q[2], q[3]))
|
||||
val s = sin(PI / 6).toFloat(); val c = cos(PI / 6).toFloat()
|
||||
assertVec(floatArrayOf(-s, 0f, -c), HeadPose.apply(view, floatArrayOf(0f, 0f, -1f)))
|
||||
assertVec(floatArrayOf(0f, 1f, 0f), HeadPose.apply(view, floatArrayOf(0f, 1f, 0f)))
|
||||
}
|
||||
|
||||
@Test fun glassesRecenterKeepsTheHorizon() {
|
||||
val q = quat(0f, 0f, 1f, 75.0)
|
||||
val ref = HeadPose.recenter(HeadPose.fromGlasses(q[0], q[1], q[2], q[3]))
|
||||
assertVec(HeadPose.IDENTITY, HeadPose.relative(ref, HeadPose.fromGlasses(q[0], q[1], q[2], q[3])))
|
||||
val tilt = quat(0f, 1f, 0f, 20.0)
|
||||
val both = HeadPose.multiply(HeadPose.fromQuaternion(q[0], q[1], q[2], q[3]), HeadPose.fromQuaternion(tilt[0], tilt[1], tilt[2], tilt[3]))
|
||||
val view = HeadPose.multiply(HeadPose.transpose(ref.basis), HeadPose.multiply(both, floatArrayOf(0f, 0f, -1f, -1f, 0f, 0f, 0f, 1f, 0f)))
|
||||
val ahead = HeadPose.apply(view, floatArrayOf(0f, 0f, -1f))
|
||||
assertEquals(0f, ahead[0], eps)
|
||||
assertEquals(-sin(PI / 9).toFloat(), ahead[1], eps)
|
||||
}
|
||||
|
||||
@Test fun monoIsNotPartOfTheSavedSettings() {
|
||||
val c = Cardboard(enabled = true, mono = true)
|
||||
assertEquals(false, Cardboard.decode(c.encode()).mono)
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user