OutputTrackerToggle

This commit is contained in:
Erimel committed 2026-07-14 15:53:31 -04:00
1 parent 8c49a7dcc2
commit 6378eb30cd
9 files changed
+197 -9

No files matched your search

@@ -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()
@@ -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<BodyPart> = listOf(),
val sendDerivedVelocity: Boolean = false,
@@ -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)
}
}
}
@@ -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<BodyPart>,
)
sealed interface OutputTrackerToggleActions {
data class SetOutputTrackers(val trackers: List<BodyPart>) : OutputTrackerToggleActions
}
typealias OutputTrackerToggleContext = Context<OutputTrackerToggleState, OutputTrackerToggleActions>
typealias OutputTrackerToggleBehaviour = Behaviour<OutputTrackerToggleState, OutputTrackerToggleActions, OutputTrackerToggleManager>
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)
}
}
}
@@ -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))
@@ -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<OutputTrackersSettingsRequest> {
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<ChangeOutputTrackersSettingsRequest> { 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,
),
)
},
)
}
}
}