From 6378eb30cdcdcc40410d30ddffdbd379f5c367b3 Mon Sep 17 00:00:00 2001 From: Erimel Date: Tue, 14 Jul 2026 15:53:31 -0400 Subject: [PATCH] OutputTrackerToggle --- .../pages/components/OutputSettings.tsx | 18 ++-- .../dev/slimevr/android/ForegroundService.kt | 3 + .../src/main/java/dev/slimevr/app-context.kt | 4 + .../main/java/dev/slimevr/config/settings.kt | 3 + .../slimevr/outputtrackertoggle/behaviours.kt | 86 +++++++++++++++++++ .../dev/slimevr/outputtrackertoggle/module.kt | 44 ++++++++++ .../main/java/dev/slimevr/solarxr/module.kt | 1 + .../dev/slimevr/solarxr/outputtrackers.kt | 44 ++++++++++ .../src/main/java/dev/slimevr/desktop/Main.kt | 3 + 9 files changed, 197 insertions(+), 9 deletions(-) create mode 100644 server/core/src/main/java/dev/slimevr/outputtrackertoggle/behaviours.kt create mode 100644 server/core/src/main/java/dev/slimevr/outputtrackertoggle/module.kt create mode 100644 server/core/src/main/java/dev/slimevr/solarxr/outputtrackers.kt diff --git a/gui/app/src/components/settings/pages/components/OutputSettings.tsx b/gui/app/src/components/settings/pages/components/OutputSettings.tsx index f86be4c7c..3eb6be8bd 100644 --- a/gui/app/src/components/settings/pages/components/OutputSettings.tsx +++ b/gui/app/src/components/settings/pages/components/OutputSettings.tsx @@ -54,10 +54,10 @@ const defaultValues: OutputTrackersForm = { // The tracker is at the tail of the bone. // Example, the waist tracker is at the tail of the hip bone so we use the hip BodyPart -function trackersToBodyPartList( +function togglesToBodyParts( trackers: OutputTrackersForm['trackers'] ): BodyPart[] { - const enabledBodyParts: [boolean, BodyPart][] = [ + const toggleToBodyPart: [boolean, BodyPart][] = [ [trackers.waist, BodyPart.HIP], [trackers.chest, BodyPart.CHEST], [trackers.leftFoot, BodyPart.LEFT_FOOT], @@ -70,12 +70,12 @@ function trackersToBodyPartList( [trackers.rightHand, BodyPart.RIGHT_HAND], ]; - return enabledBodyParts + return toggleToBodyPart .filter(([enabled]) => enabled) .map(([, part]) => part); } -function bodyPartListToTrackers( +function bodyPartsToTrackers( bodyParts: BodyPart[] ): OutputTrackersForm['trackers'] { const set = new Set(bodyParts); @@ -146,7 +146,7 @@ export function OutputTrackersSettings() { blockHandsWarning.current = false; } - settingsReq.trackers = trackersToBodyPartList({ + settingsReq.trackers = togglesToBodyParts({ ...values.trackers, leftHand, rightHand, @@ -176,14 +176,14 @@ export function OutputTrackersSettings() { if (settings.trackers) { formData = { - ...bodyPartListToTrackers(settings.trackers), + trackers: bodyPartsToTrackers(settings.trackers), automaticTrackerToggle: settings.automaticTrackerToggle, sendDerivedVelocity: settings.sendDerivedVelocity, }; if ( - !blockHandsWarning.current && - (settings.trackers.includes(BodyPart.LEFT_HAND) || - settings.trackers.includes(BodyPart.RIGHT_HAND)) + !blockHandsWarning.current && + (settings.trackers.includes(BodyPart.LEFT_HAND) || + settings.trackers.includes(BodyPart.RIGHT_HAND)) ) { blockHandsWarning.current = true; } diff --git a/server/android/src/main/java/dev/slimevr/android/ForegroundService.kt b/server/android/src/main/java/dev/slimevr/android/ForegroundService.kt index bd0f749e8..e9269b381 100644 --- a/server/android/src/main/java/dev/slimevr/android/ForegroundService.kt +++ b/server/android/src/main/java/dev/slimevr/android/ForegroundService.kt @@ -29,6 +29,7 @@ import dev.slimevr.config.AppConfig import dev.slimevr.firmware.FirmwareManager import dev.slimevr.heightcalibration.HeightCalibrationManager import dev.slimevr.networkprofile.NetworkProfileManager +import dev.slimevr.outputtrackertoggle.OutputTrackerToggleManager import dev.slimevr.provisioning.ProvisioningManager import dev.slimevr.resets.ResetsManager import dev.slimevr.skeleton.Skeleton @@ -145,6 +146,7 @@ class ForegroundService : Service() { val heightCalibrationManager = HeightCalibrationManager.create(ctx = phase1, scope = scope) val trackingChecklist = TrackingChecklist.create(scope = scope) val udpServer = UdpServer.create(scope = scope, addressResolver = ::resolveAndroidUdpAddress) + val outputTrackerToggle = OutputTrackerToggleManager.create(ctx = phase1, scope = scope) val bvhManager = BVHManager.create(skeleton = skeleton, storage = storage, scope = scope) val vmcManager = VMCManager.create(ctx = phase1, skeleton = skeleton, scope = scope) val vrcOscManager = VRCOSCManager.create( @@ -168,6 +170,7 @@ class ForegroundService : Service() { heightCalibrationManager = heightCalibrationManager, trackingChecklist = trackingChecklist, udpServer = udpServer, + outputTrackerToggle = outputTrackerToggle, bvhManager = bvhManager, vmcManager = vmcManager, vrcOscManager = vrcOscManager, diff --git a/server/core/src/main/java/dev/slimevr/app-context.kt b/server/core/src/main/java/dev/slimevr/app-context.kt index 16cea2d0a..9fd9cec10 100644 --- a/server/core/src/main/java/dev/slimevr/app-context.kt +++ b/server/core/src/main/java/dev/slimevr/app-context.kt @@ -1,5 +1,6 @@ package dev.slimevr +import dev.slimevr.outputtrackertoggle.OutputTrackerToggleManager import dev.slimevr.bvh.BVHManager import dev.slimevr.config.AppConfig import dev.slimevr.firmware.FirmwareManager @@ -38,6 +39,7 @@ interface AppContextProvider : Phase1ContextProvider { val heightCalibrationManager: HeightCalibrationManager val trackingChecklist: TrackingChecklist val udpServer: UdpServer + val outputTrackerToggle: OutputTrackerToggleManager val bvhManager: BVHManager val vmcManager: VMCManager val vrcOscManager: VRCOSCManager @@ -60,6 +62,7 @@ class AppContext( override val heightCalibrationManager: HeightCalibrationManager, override val trackingChecklist: TrackingChecklist, override val udpServer: UdpServer, + override val outputTrackerToggle: OutputTrackerToggleManager, override val bvhManager: BVHManager, override val vmcManager: VMCManager, override val vrcOscManager: VRCOSCManager, @@ -75,6 +78,7 @@ class AppContext( networkProfileManager?.startObserving() trackingChecklist.startObserving(this) udpServer.startReceiving(this, server.context.scope) + outputTrackerToggle.startObserving() vmcManager.startObserving() vrcOscManager.startObserving(this) resetsManager.startObserving() diff --git a/server/core/src/main/java/dev/slimevr/config/settings.kt b/server/core/src/main/java/dev/slimevr/config/settings.kt index 9b52f87c5..a2b4918e3 100644 --- a/server/core/src/main/java/dev/slimevr/config/settings.kt +++ b/server/core/src/main/java/dev/slimevr/config/settings.kt @@ -43,6 +43,9 @@ data class HidConfig( @Serializable data class OutputTrackersConfig( val automaticTrackerToggle: Boolean = true, + /** + * Do not read from directly, instead use + */ @Serializable(with = BodyPartListSerializer::class) val trackers: List = listOf(), val sendDerivedVelocity: Boolean = false, diff --git a/server/core/src/main/java/dev/slimevr/outputtrackertoggle/behaviours.kt b/server/core/src/main/java/dev/slimevr/outputtrackertoggle/behaviours.kt new file mode 100644 index 000000000..250824818 --- /dev/null +++ b/server/core/src/main/java/dev/slimevr/outputtrackertoggle/behaviours.kt @@ -0,0 +1,86 @@ +package dev.slimevr.outputtrackertoggle + +import kotlinx.coroutines.ExperimentalCoroutinesApi +import kotlinx.coroutines.flow.combine +import kotlinx.coroutines.flow.distinctUntilChanged +import kotlinx.coroutines.flow.filter +import kotlinx.coroutines.flow.flatMapLatest +import kotlinx.coroutines.flow.launchIn +import kotlinx.coroutines.flow.map +import kotlinx.coroutines.flow.onEach +import solarxr_protocol.datatypes.BodyPart +import solarxr_protocol.datatypes.TrackerStatus +import solarxr_protocol.rpc.OutputTrackersSettingsResponse +import kotlin.collections.filter +import kotlin.collections.map + +private val automaticToggleToTracker = mapOf( + BodyPart.CHEST to setOf(BodyPart.UPPER_CHEST, BodyPart.CHEST), + BodyPart.LEFT_UPPER_ARM to setOf(BodyPart.LEFT_UPPER_ARM, BodyPart.LEFT_LOWER_ARM), + BodyPart.RIGHT_UPPER_ARM to setOf(BodyPart.RIGHT_UPPER_ARM, BodyPart.RIGHT_LOWER_ARM), + BodyPart.HIP to setOf(BodyPart.UPPER_CHEST, BodyPart.CHEST, BodyPart.WAIST, BodyPart.HIP), + BodyPart.LEFT_UPPER_LEG to setOf(BodyPart.LEFT_UPPER_LEG), + BodyPart.RIGHT_UPPER_LEG to setOf(BodyPart.RIGHT_UPPER_LEG), + BodyPart.LEFT_FOOT to setOf(BodyPart.LEFT_LOWER_LEG, BodyPart.LEFT_FOOT), + BodyPart.RIGHT_FOOT to setOf(BodyPart.RIGHT_LOWER_LEG, BodyPart.RIGHT_FOOT), +) + +class OutputTrackerToggleBasicBehaviour : OutputTrackerToggleBehaviour { + @OptIn(ExperimentalCoroutinesApi::class) + override fun observe(receiver: OutputTrackerToggleManager) { + receiver.settings.context.state + .map { it.data.outputTrackersConfig } + .distinctUntilChanged() + .onEach { config -> + if (!config.automaticTrackerToggle) { + // Manual + receiver.context.dispatch(OutputTrackerToggleActions.SetOutputTrackers(config.trackers)) + } + } + .filter { it.automaticTrackerToggle } // Automatic + .flatMapLatest { config -> + receiver.server.context.state + .map { it.trackers.values } + .flatMapLatest { trackers -> + combine(trackers.map { it.context.state }) { states -> + states.map { it.bodyPart to it.status } + } + .distinctUntilChanged() + .map { trackerStates -> + trackerStates + .filter { it.second == TrackerStatus.OK } + .map { it.first } + .toSet() + } + } + .map { okBodyParts -> config to okBodyParts } + } + .onEach { (config, okBodyParts) -> + val automaticTrackers = automaticToggleToTracker + .filterValues { it.any { bp -> bp in okBodyParts } } + .keys + // Hands aren't toggled automatically + val handTrackers = config.trackers.filter { + it == BodyPart.LEFT_HAND || it == BodyPart.RIGHT_HAND + } + val outputTrackers = (automaticTrackers + handTrackers).toList() + + // Update state + receiver.context.dispatch(OutputTrackerToggleActions.SetOutputTrackers(outputTrackers)) + + // Update SolarXR + receiver.server.sendSolarxrRpc(OutputTrackersSettingsResponse( + automaticTrackerToggle = true, + trackers = outputTrackers, + sendDerivedVelocity = config.sendDerivedVelocity, + ),) + } + .launchIn(receiver.context.scope) + } + + override fun reduce(state: OutputTrackerToggleState, action: OutputTrackerToggleActions) = when (action) { + is OutputTrackerToggleActions.SetOutputTrackers -> { + state.copy(trackers = action.trackers) + } + } +} diff --git a/server/core/src/main/java/dev/slimevr/outputtrackertoggle/module.kt b/server/core/src/main/java/dev/slimevr/outputtrackertoggle/module.kt new file mode 100644 index 000000000..384cdc1e1 --- /dev/null +++ b/server/core/src/main/java/dev/slimevr/outputtrackertoggle/module.kt @@ -0,0 +1,44 @@ +package dev.slimevr.outputtrackertoggle + +import dev.slimevr.Phase1ContextProvider +import dev.slimevr.VRServer +import dev.slimevr.config.Settings +import dev.slimevr.context.Behaviour +import dev.slimevr.context.Context +import kotlinx.coroutines.CoroutineScope +import solarxr_protocol.datatypes.BodyPart +import kotlin.collections.listOf + +data class OutputTrackerToggleState( + /** + * The output trackers should be on the tail of the present BodyParts + * Example: for the SteamVR waist tracker, since it uses the hip's rotation and tail position, + * we check for BodyPart.HIP. + */ + val trackers: List, +) + +sealed interface OutputTrackerToggleActions { + data class SetOutputTrackers(val trackers: List) : OutputTrackerToggleActions +} + +typealias OutputTrackerToggleContext = Context +typealias OutputTrackerToggleBehaviour = Behaviour + +class OutputTrackerToggleManager(val context: OutputTrackerToggleContext, val server: VRServer, val settings: Settings) { + fun startObserving() = context.observeAll(this) + + companion object { + fun create(ctx: Phase1ContextProvider, scope: CoroutineScope): OutputTrackerToggleManager { + val context = Context.create( + initialState = OutputTrackerToggleState( + trackers = listOf(), + ), + scope = scope, + behaviours = listOf(OutputTrackerToggleBasicBehaviour()), + name = "OutputTrackerToggleManager", + ) + return OutputTrackerToggleManager(context, ctx.server, ctx.config.settings) + } + } +} diff --git a/server/core/src/main/java/dev/slimevr/solarxr/module.kt b/server/core/src/main/java/dev/slimevr/solarxr/module.kt index eefe4d8fc..ad5a8f012 100644 --- a/server/core/src/main/java/dev/slimevr/solarxr/module.kt +++ b/server/core/src/main/java/dev/slimevr/solarxr/module.kt @@ -77,6 +77,7 @@ class SolarXRBridge( add(VmcBehaviour(appContext.config.settings)) add(HeightCalibrationBehaviour(appContext.heightCalibrationManager)) add(ProvisioningBehaviour(appContext.server, appContext.provisioningManager)) + add(OutputTrackersBehaviour(appContext.config.settings, appContext.outputTrackerToggle)) add(SkeletonSettingsBehaviour(appContext.config.settings)) add(SkeletonProportionsBehaviour(appContext.config.userConfig, appContext.skeleton)) add(TrackingChecklistBehaviour(appContext.trackingChecklist, appContext.config.settings)) diff --git a/server/core/src/main/java/dev/slimevr/solarxr/outputtrackers.kt b/server/core/src/main/java/dev/slimevr/solarxr/outputtrackers.kt new file mode 100644 index 000000000..0e1f4a772 --- /dev/null +++ b/server/core/src/main/java/dev/slimevr/solarxr/outputtrackers.kt @@ -0,0 +1,44 @@ +package dev.slimevr.solarxr + +import dev.slimevr.outputtrackertoggle.OutputTrackerToggleManager +import dev.slimevr.config.OutputTrackersConfig +import dev.slimevr.config.Settings +import dev.slimevr.config.SettingsActions +import solarxr_protocol.rpc.ChangeOutputTrackersSettingsRequest +import solarxr_protocol.rpc.OutputTrackersSettingsRequest +import solarxr_protocol.rpc.OutputTrackersSettingsResponse + +class OutputTrackersBehaviour( + private val settings: Settings, + private val outputTrackerToggleManager: OutputTrackerToggleManager, +) : SolarXRBridgeBehaviour { + override fun observe(receiver: SolarXRBridge) { + // Send config + receiver.rpcDispatcher.on { + val config = settings.context.state.value.data.outputTrackersConfig + receiver.sendRpc( + OutputTrackersSettingsResponse( + automaticTrackerToggle = config.automaticTrackerToggle, + trackers = outputTrackerToggleManager.context.state.value.trackers, + sendDerivedVelocity = config.sendDerivedVelocity, + ), + ) + } + + // Receive config + receiver.rpcDispatcher.on { req -> + val oldConfig = settings.context.state.value.data.outputTrackersConfig + settings.context.dispatch( + SettingsActions.Update { + copy( + outputTrackersConfig = OutputTrackersConfig( + automaticTrackerToggle = req.automaticTrackerToggle == true, + trackers = req.trackers ?: oldConfig.trackers, + sendDerivedVelocity = req.sendDerivedVelocity == true, + ), + ) + }, + ) + } + } +} diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt b/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt index 353f516d2..f674935ec 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt +++ b/server/desktop/src/main/java/dev/slimevr/desktop/Main.kt @@ -27,6 +27,7 @@ import dev.slimevr.desktop.vrchat.resolveDesktopOscQueryAddress import dev.slimevr.firmware.FirmwareManager import dev.slimevr.heightcalibration.HeightCalibrationManager import dev.slimevr.networkprofile.NetworkProfileManager +import dev.slimevr.outputtrackertoggle.OutputTrackerToggleManager import dev.slimevr.provisioning.ProvisioningManager import dev.slimevr.resets.ResetsManager import dev.slimevr.resolveConfigDirectory @@ -91,6 +92,7 @@ fun main(args: Array) = runBlocking { } }) val udpServer = UdpServer.create(scope = this, addressResolver = ::resolveDesktopUdpAddress) + val outputTrackerToggle = OutputTrackerToggleManager.create(ctx = phase1, scope = this) val bvhManager = BVHManager.create(skeleton = skeleton, storage = storage, scope = this) val vmcManager = VMCManager.create(ctx = phase1, skeleton = skeleton, scope = this) val vrcOscManager = VRCOSCManager.create( @@ -114,6 +116,7 @@ fun main(args: Array) = runBlocking { heightCalibrationManager = heightCalibrationManager, trackingChecklist = trackingChecklist, udpServer = udpServer, + outputTrackerToggle = outputTrackerToggle, bvhManager = bvhManager, vmcManager = vmcManager, vrcOscManager = vrcOscManager,