mirror of
https://github.com/SlimeVR/SlimeVR-Server.git
synced 2026-11-20 09:01:20 -08:00
Bone Routing from pack
This commit is contained in:
1 parent
efeada35fa
commit
dcabe69bc8
12 files changed
+293
-187
No files matched your search
@@ -4,6 +4,7 @@ import dev.slimevr.resourcepacks.FixedProportionDefault
|
||||
import dev.slimevr.resourcepacks.HeightRatioProportionDefault
|
||||
import dev.slimevr.resourcepacks.ProportionDefault
|
||||
import io.github.axisangles.ktmath.Vector3
|
||||
import solarxr_protocol.rpc.RoutingOutput
|
||||
import solarxr_protocol.rpc.SkeletonBone
|
||||
|
||||
private fun resolveDefault(default: ProportionDefault, height: Float): Float = when (default) {
|
||||
@@ -49,8 +50,8 @@ data class CompiledOffset(val base: Vector3, val terms: List<CompiledOffsetTerm>
|
||||
class BoneOffsets(val tail: BoneMap<Vector3>, val head: BoneMap<Vector3>)
|
||||
|
||||
/**
|
||||
* The compiled bone registry, proportion catalog, and per-bone offset, constraint, and
|
||||
* rotation-fallback rule produced by [compileResourcePacks]. [copyRotationFallbacks] (bone to
|
||||
* The compiled bone registry, proportion catalog, per-bone offset, constraint, rotation-fallback
|
||||
* rule, and routing fact produced by [compileResourcePacks]. [copyRotationFallbacks] (bone to
|
||||
* source) and [firstActiveRotationFallbacks] (bone to source list) are each in
|
||||
* ancestor-before-descendant order on their own; every core bone's `copy` source that itself needs
|
||||
* resolving first is its own parent, and a `firstActive` bone's only source that ever needs
|
||||
@@ -66,7 +67,34 @@ class CompiledSkeleton(
|
||||
val constraints: BoneMap<Constraint>,
|
||||
val copyRotationFallbacks: List<Pair<BoneId, BoneId>>,
|
||||
val firstActiveRotationFallbacks: List<Pair<BoneId, List<BoneId>>>,
|
||||
private val driverOutputs: BoneSet,
|
||||
private val vmcOutputs: BoneSet,
|
||||
private val vrchatOutputs: BoneSet,
|
||||
private val vrchatRequired: BoneSet,
|
||||
val overridableBones: BoneSet,
|
||||
private val candidateSources: BoneMap<List<BoneId>>,
|
||||
) {
|
||||
/** Bones [output] can receive, from each bone's `outputs.driver`/`outputs.vmc`/`outputs.vrchat`. */
|
||||
fun acceptedBones(output: RoutingOutput): Set<BoneId> = when (output) {
|
||||
RoutingOutput.DRIVER -> driverOutputs
|
||||
RoutingOutput.VMC -> vmcOutputs
|
||||
RoutingOutput.VRC_OSC -> vrchatOutputs
|
||||
}
|
||||
|
||||
/**
|
||||
* Bones [output] that are required and cannot be disabled
|
||||
*/
|
||||
fun requiredBones(output: RoutingOutput): Set<BoneId> = when (output) {
|
||||
RoutingOutput.DRIVER -> emptySet()
|
||||
RoutingOutput.VMC -> vmcOutputs
|
||||
RoutingOutput.VRC_OSC -> vrchatRequired
|
||||
}
|
||||
|
||||
/** Bones with a `candidateSources` list, each naming the bones that make it a routing candidate. */
|
||||
val candidateBones: Set<BoneId> get() = candidateSources.keys
|
||||
|
||||
fun candidateSourcesOf(boneId: BoneId): List<BoneId> = candidateSources[boneId] ?: emptyList()
|
||||
|
||||
/** Every proportion's default value at [height], keyed by proportion key. */
|
||||
fun defaultProportionValues(height: Float = REFERENCE_HEIGHT): Map<String, Float> {
|
||||
val result = mutableMapOf<String, Float>()
|
||||
|
||||
@@ -146,6 +146,12 @@ fun compileResourcePacks(catalog: ResourcePackCatalog): CompiledSkeleton {
|
||||
val constraints = BoneMap.of<Constraint>(registry)
|
||||
val copyFallbacksByBoneId = mutableMapOf<BoneId, Pair<BoneContribution, CopyRotationFallback>>()
|
||||
val firstActiveFallbacksByBoneId = mutableMapOf<BoneId, Pair<BoneContribution, FirstActiveRotationFallback>>()
|
||||
val driverOutputs = BoneSet.of(registry)
|
||||
val vmcOutputs = BoneSet.of(registry)
|
||||
val vrchatOutputs = BoneSet.of(registry)
|
||||
val vrchatRequired = BoneSet.of(registry)
|
||||
val overridableBones = BoneSet.of(registry)
|
||||
val candidateSources = BoneMap.of<List<BoneId>>(registry)
|
||||
for (contribution in allContributions) {
|
||||
val definition = contribution.resource.value
|
||||
val boneId = registry[definition.key] ?: continue
|
||||
@@ -157,6 +163,16 @@ fun compileResourcePacks(catalog: ResourcePackCatalog): CompiledSkeleton {
|
||||
is CopyRotationFallback -> copyFallbacksByBoneId[boneId] = contribution to fallback
|
||||
is FirstActiveRotationFallback -> firstActiveFallbacksByBoneId[boneId] = contribution to fallback
|
||||
}
|
||||
definition.outputs?.driver?.let { driverOutputs.add(boneId) }
|
||||
definition.outputs?.vmc?.let { vmcOutputs.add(boneId) }
|
||||
definition.outputs?.vrchat?.let {
|
||||
vrchatOutputs.add(boneId)
|
||||
if (it.required == true) vrchatRequired.add(boneId)
|
||||
}
|
||||
if (definition.overridable == true) overridableBones.add(boneId)
|
||||
definition.candidateSources?.let { sources ->
|
||||
candidateSources[boneId] = sources.map { resolveBoneKey(it, contribution, "candidateSources", registry, diagnostics) }
|
||||
}
|
||||
}
|
||||
val hierarchyOrder = registry.hierarchyFrom(registry.root).map { it.second }
|
||||
val copyRotationFallbacks = hierarchyOrder.mapNotNull { boneId ->
|
||||
@@ -169,7 +185,10 @@ fun compileResourcePacks(catalog: ResourcePackCatalog): CompiledSkeleton {
|
||||
}
|
||||
if (diagnostics.isNotEmpty()) throw ResourcePackCompilationException(diagnostics)
|
||||
|
||||
return CompiledSkeleton(registry, proportions, tailOffsets, headOffsets, constraints, copyRotationFallbacks, firstActiveRotationFallbacks)
|
||||
return CompiledSkeleton(
|
||||
registry, proportions, tailOffsets, headOffsets, constraints, copyRotationFallbacks, firstActiveRotationFallbacks,
|
||||
driverOutputs, vmcOutputs, vrchatOutputs, vrchatRequired, overridableBones, candidateSources,
|
||||
)
|
||||
}
|
||||
|
||||
private fun compileConstraint(constraint: PackConstraint): Constraint = when (constraint) {
|
||||
@@ -193,6 +212,20 @@ private fun compileConstraint(constraint: PackConstraint): Constraint = when (co
|
||||
)
|
||||
}
|
||||
|
||||
/** Resolves a bone key referenced from [contribution], reporting [context] on an unknown key. */
|
||||
private fun resolveBoneKey(
|
||||
key: String,
|
||||
contribution: BoneContribution,
|
||||
context: String,
|
||||
registry: BoneRegistry,
|
||||
diagnostics: MutableList<ResourcePackCompilationDiagnostic>,
|
||||
): BoneId {
|
||||
val boneId = registry[key]
|
||||
if (boneId != null) return boneId
|
||||
diagnostics += ResourcePackCompilationDiagnostic(contribution.pack.manifest.value.id, contribution.resource.path, "Unknown bone '$key' in $context")
|
||||
return BoneId(0u)
|
||||
}
|
||||
|
||||
/** Resolves one rotation-fallback source key (or the `"parent"` shorthand) to a [BoneId]. */
|
||||
private fun resolveFallbackBone(
|
||||
key: String,
|
||||
@@ -201,10 +234,11 @@ private fun resolveFallbackBone(
|
||||
diagnostics: MutableList<ResourcePackCompilationDiagnostic>,
|
||||
): BoneId {
|
||||
val target = if (key == "parent") contribution.resource.value.parent else key
|
||||
val boneId = target?.let { registry[it] }
|
||||
if (boneId != null) return boneId
|
||||
diagnostics += ResourcePackCompilationDiagnostic(contribution.pack.manifest.value.id, contribution.resource.path, "Unknown bone '$key' in rotationFallback")
|
||||
return BoneId(0u)
|
||||
if (target == null) {
|
||||
diagnostics += ResourcePackCompilationDiagnostic(contribution.pack.manifest.value.id, contribution.resource.path, "Unknown bone '$key' in rotationFallback")
|
||||
return BoneId(0u)
|
||||
}
|
||||
return resolveBoneKey(target, contribution, "rotationFallback", registry, diagnostics)
|
||||
}
|
||||
|
||||
private fun compileOffset(
|
||||
|
||||
@@ -16,7 +16,7 @@ class BoneRoutingBasicBehaviour(private val appContext: AppContextProvider) : Bo
|
||||
override fun observe(receiver: BoneRoutingManager) {
|
||||
val server = appContext.server
|
||||
val settings = appContext.config.settings
|
||||
val registry = appContext.bones.current
|
||||
val definition = appContext.skeleton.definition
|
||||
|
||||
combine(
|
||||
settings.context.state.map { it.data.boneRoutingConfig }.distinctUntilChanged(),
|
||||
@@ -27,7 +27,7 @@ class BoneRoutingBasicBehaviour(private val appContext: AppContextProvider) : Bo
|
||||
if (!config.automatic) {
|
||||
receiver.context.dispatch(
|
||||
BoneRoutingActions.SetRoutes(
|
||||
effectiveRoutes(manualRoutesAsBoneIds(config.manualRoutes, registry), outputStates, registry),
|
||||
effectiveRoutes(manualRoutesAsBoneIds(config.manualRoutes, definition), outputStates, definition),
|
||||
),
|
||||
)
|
||||
}
|
||||
@@ -47,19 +47,19 @@ class BoneRoutingBasicBehaviour(private val appContext: AppContextProvider) : Bo
|
||||
trackers.map { tracker ->
|
||||
tracker.context.state.distinctUntilChanged { a, b -> a.boneId == b.boneId && a.status == b.status }
|
||||
},
|
||||
) { states -> trackedBodyParts(states.asList(), registry) }
|
||||
) { states -> trackedBoneIds(states.asList()) }
|
||||
.distinctUntilChanged()
|
||||
}
|
||||
.map { fineBodyParts -> Triple(config, outputStates, fineBodyParts) }
|
||||
.map { boneIds -> Triple(config, outputStates, boneIds) }
|
||||
}
|
||||
.onEach { (config, outputStates, fineBodyParts) ->
|
||||
val candidates = determineCandidateBones(fineBodyParts)
|
||||
.onEach { (config, outputStates, boneIds) ->
|
||||
val candidates = determineCandidateBones(boneIds, definition)
|
||||
receiver.context.dispatch(
|
||||
BoneRoutingActions.SetRoutes(
|
||||
effectiveRoutes(
|
||||
computeAutomaticRoutes(candidates, outputStates, registry) + overrideRoutes(config, registry),
|
||||
computeAutomaticRoutes(candidates, outputStates, definition) + overrideRoutes(config, definition),
|
||||
outputStates,
|
||||
registry,
|
||||
definition,
|
||||
),
|
||||
),
|
||||
)
|
||||
|
||||
@@ -3,13 +3,10 @@ package dev.slimevr.routing
|
||||
import dev.slimevr.AppContextProvider
|
||||
import dev.slimevr.bones.BodyPart
|
||||
import dev.slimevr.bones.BoneId
|
||||
import dev.slimevr.bones.BoneRegistry
|
||||
import dev.slimevr.bones.CompiledSkeleton
|
||||
import dev.slimevr.config.BoneRoutingConfig
|
||||
import dev.slimevr.solarxr.driver.DRIVER_SUPPORTED_BONES
|
||||
import dev.slimevr.tracker.TrackerState
|
||||
import dev.slimevr.util.isActive
|
||||
import dev.slimevr.vmc.VMC_SUPPORTED_BONES
|
||||
import dev.slimevr.vrcosc.VRC_OSC_SUPPORTED_BONES
|
||||
import kotlinx.coroutines.ExperimentalCoroutinesApi
|
||||
import kotlinx.coroutines.flow.Flow
|
||||
import kotlinx.coroutines.flow.combine
|
||||
@@ -30,11 +27,7 @@ private val ALL_ACTIVE: OutputStates = RoutingOutput.entries.associateWith { Rou
|
||||
|
||||
private val PRIORITY_CHAIN = listOf(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC)
|
||||
|
||||
fun acceptedBones(output: RoutingOutput): Set<BodyPart> = when (output) {
|
||||
RoutingOutput.DRIVER -> DRIVER_SUPPORTED_BONES
|
||||
RoutingOutput.VRC_OSC -> VRC_OSC_SUPPORTED_BONES
|
||||
RoutingOutput.VMC -> VMC_SUPPORTED_BONES
|
||||
}
|
||||
fun acceptedBones(output: RoutingOutput, definition: CompiledSkeleton): Set<BoneId> = definition.acceptedBones(output)
|
||||
|
||||
fun conflictingOutputs(output: RoutingOutput): Set<RoutingOutput> = when (output) {
|
||||
in PRIORITY_CHAIN -> PRIORITY_CHAIN.toSet() - output
|
||||
@@ -42,32 +35,19 @@ fun conflictingOutputs(output: RoutingOutput): Set<RoutingOutput> = when (output
|
||||
}
|
||||
|
||||
/** Bones an output needs to work at all, so the user cannot turn them off. */
|
||||
fun requiredBones(output: RoutingOutput): Set<BodyPart> = when (output) {
|
||||
RoutingOutput.DRIVER, RoutingOutput.VRC_OSC -> emptySet()
|
||||
RoutingOutput.VMC -> VMC_SUPPORTED_BONES
|
||||
}
|
||||
fun requiredBones(output: RoutingOutput, definition: CompiledSkeleton): Set<BoneId> = definition.requiredBones(output)
|
||||
|
||||
/**
|
||||
* Bones automatic never routes on its own. Sending a hand to the driver takes over the
|
||||
* real controllers, so it stays the user's call whatever the mode.
|
||||
*/
|
||||
val OVERRIDABLE_BONES: Set<BodyPart> = setOf(BodyPart.LEFT_HAND, BodyPart.RIGHT_HAND)
|
||||
fun overridableBones(output: RoutingOutput, definition: CompiledSkeleton): Set<BoneId> = definition.overridableBones intersect acceptedBones(output, definition) subtract requiredBones(output, definition)
|
||||
|
||||
fun overridableBones(output: RoutingOutput): Set<BodyPart> = OVERRIDABLE_BONES intersect acceptedBones(output) subtract requiredBones(output)
|
||||
fun manualRoutesAsBoneIds(manualRoutes: Map<String, Set<RoutingOutput>>?, definition: CompiledSkeleton): Routes = manualRoutes.orEmpty().mapNotNull { (key, outputs) -> definition.registry[key]?.let { it to outputs } }.toMap()
|
||||
|
||||
/** Resolves a static [BodyPart] set to the [BoneId]s a specific registry gives them. */
|
||||
private fun BoneRegistry.idsOf(bodyParts: Set<BodyPart>): Set<BoneId> = bodyParts.mapNotNullTo(mutableSetOf()) { this[it] }
|
||||
fun Routes.toManualRoutesConfig(definition: CompiledSkeleton): Map<String, Set<RoutingOutput>> = mapNotNull { (boneId, outputs) -> definition.registry.keyOf(boneId)?.let { it to outputs } }.toMap()
|
||||
|
||||
private fun BoneRegistry.acceptedIds(output: RoutingOutput): Set<BoneId> = idsOf(acceptedBones(output))
|
||||
private fun BoneRegistry.requiredIds(output: RoutingOutput): Set<BoneId> = idsOf(requiredBones(output))
|
||||
|
||||
fun manualRoutesAsBoneIds(manualRoutes: Map<String, Set<RoutingOutput>>?, registry: BoneRegistry): Routes = manualRoutes.orEmpty().mapNotNull { (key, outputs) -> registry[key]?.let { it to outputs } }.toMap()
|
||||
fun Routes.toManualRoutesConfig(registry: BoneRegistry): Map<String, Set<RoutingOutput>> = mapNotNull { (boneId, outputs) -> registry.keyOf(boneId)?.let { it to outputs } }.toMap()
|
||||
|
||||
fun overrideRoutes(config: BoneRoutingConfig, registry: BoneRegistry): Routes {
|
||||
val overridableIds = registry.idsOf(OVERRIDABLE_BONES)
|
||||
return manualRoutesAsBoneIds(config.manualRoutes, registry).filterKeys { it in overridableIds }
|
||||
}
|
||||
fun overrideRoutes(config: BoneRoutingConfig, definition: CompiledSkeleton): Routes = manualRoutesAsBoneIds(config.manualRoutes, definition).filterKeys { it in definition.overridableBones }
|
||||
|
||||
fun isActive(states: OutputStates, output: RoutingOutput): Boolean = states[output] == RoutingOutputState.ACTIVE
|
||||
|
||||
@@ -121,24 +101,24 @@ fun intendedRoutesFlow(appContext: AppContextProvider): Flow<Routes> = combine(
|
||||
appContext.config.settings.context.state.map { it.data.boneRoutingConfig }.distinctUntilChanged(),
|
||||
appContext.boneRouting.context.state.map { it.routes },
|
||||
) { config, sent ->
|
||||
val registry = appContext.bones.current
|
||||
val requested = if (config.automatic) sent else manualRoutesAsBoneIds(config.manualRoutes, registry)
|
||||
effectiveRoutes(requested + overrideRoutes(config, registry), ALL_ACTIVE, registry)
|
||||
val definition = appContext.skeleton.definition
|
||||
val requested = if (config.automatic) sent else manualRoutesAsBoneIds(config.manualRoutes, definition)
|
||||
effectiveRoutes(requested + overrideRoutes(config, definition), ALL_ACTIVE, definition)
|
||||
}.distinctUntilChanged()
|
||||
|
||||
/**
|
||||
* What actually gets sent: the requested routes plus whatever each output requires,
|
||||
* minus anything an output cannot accept or cannot currently send.
|
||||
*/
|
||||
fun effectiveRoutes(routes: Routes, outputStates: OutputStates, registry: BoneRegistry): Routes {
|
||||
fun effectiveRoutes(routes: Routes, outputStates: OutputStates, definition: CompiledSkeleton): Routes {
|
||||
val result = mutableMapOf<BoneId, Set<RoutingOutput>>()
|
||||
for ((bone, outputs) in routes) {
|
||||
val kept = outputs.filterTo(mutableSetOf()) { isActive(outputStates, it) && bone in registry.acceptedIds(it) }
|
||||
val kept = outputs.filterTo(mutableSetOf()) { isActive(outputStates, it) && bone in acceptedBones(it, definition) }
|
||||
if (kept.isNotEmpty()) result[bone] = kept
|
||||
}
|
||||
for (output in RoutingOutput.entries) {
|
||||
if (!isActive(outputStates, output)) continue
|
||||
for (bone in registry.requiredIds(output)) {
|
||||
for (bone in requiredBones(output, definition)) {
|
||||
result[bone] = result[bone].orEmpty() + output
|
||||
}
|
||||
}
|
||||
@@ -149,59 +129,47 @@ fun applyRoutingChange(
|
||||
config: BoneRoutingConfig,
|
||||
automatic: Boolean,
|
||||
routes: Routes,
|
||||
registry: BoneRegistry,
|
||||
definition: CompiledSkeleton,
|
||||
): BoneRoutingConfig {
|
||||
// Switching modes only flips the switch: each mode keeps the picks left in it.
|
||||
if (automatic != config.automatic) return config.copy(automatic = automatic)
|
||||
|
||||
val requested = routes
|
||||
.mapValues { (bone, outputs) -> outputs.filterTo(mutableSetOf()) { bone in registry.acceptedIds(it) && bone !in registry.requiredIds(it) } }
|
||||
.mapValues { (bone, outputs) -> outputs.filterTo(mutableSetOf()) { bone in acceptedBones(it, definition) && bone !in requiredBones(it, definition) } }
|
||||
.filterValues { it.isNotEmpty() }
|
||||
|
||||
val overridableIds = registry.idsOf(OVERRIDABLE_BONES)
|
||||
val overridableIds = definition.overridableBones
|
||||
return config.copy(
|
||||
manualRoutes = if (automatic) {
|
||||
// Automatic owns every other bone, so only the overrides come from the request.
|
||||
(
|
||||
manualRoutesAsBoneIds(config.manualRoutes, registry).filterKeys { it !in overridableIds } +
|
||||
manualRoutesAsBoneIds(config.manualRoutes, definition).filterKeys { it !in overridableIds } +
|
||||
requested.filterKeys { it in overridableIds }
|
||||
).toManualRoutesConfig(registry)
|
||||
).toManualRoutesConfig(definition)
|
||||
} else {
|
||||
requested.toManualRoutesConfig(registry)
|
||||
requested.toManualRoutesConfig(definition)
|
||||
},
|
||||
)
|
||||
}
|
||||
|
||||
private val candidateToFineBodyParts = mapOf(
|
||||
BodyPart.UPPER_CHEST to setOf(BodyPart.UPPER_CHEST, BodyPart.LOWER_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.HIP, BodyPart.LOWER_WAIST, BodyPart.UPPER_WAIST, BodyPart.LOWER_CHEST, BodyPart.UPPER_CHEST),
|
||||
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_FOOT, BodyPart.LEFT_LOWER_LEG, BodyPart.LEFT_UPPER_LEG),
|
||||
BodyPart.RIGHT_FOOT to setOf(BodyPart.RIGHT_FOOT, BodyPart.RIGHT_LOWER_LEG, BodyPart.RIGHT_UPPER_LEG),
|
||||
)
|
||||
|
||||
/** Tracker body parts that count as present. Loopback trackers never enable an output. */
|
||||
fun trackedBodyParts(trackers: Collection<TrackerState>, registry: BoneRegistry): Set<BodyPart?> = trackers
|
||||
/** Tracker bones that count as present. Loopback trackers never enable an output. */
|
||||
fun trackedBoneIds(trackers: Collection<TrackerState>): Set<BoneId?> = trackers
|
||||
.filter {
|
||||
it.status.isActive() &&
|
||||
it.origin != DeviceOrigin.DRIVER &&
|
||||
it.origin != DeviceOrigin.VRC &&
|
||||
it.origin != DeviceOrigin.VMC
|
||||
}
|
||||
.map { it.boneId?.let { id -> registry.bodyPartOf(id) } }
|
||||
.map { it.boneId }
|
||||
.toSet()
|
||||
|
||||
fun determineCandidateBones(fineBodyParts: Set<BodyPart?>): Set<BodyPart> = candidateToFineBodyParts
|
||||
.filterValues { it.any { bp -> bp in fineBodyParts } }
|
||||
.keys
|
||||
fun determineCandidateBones(trackedBoneIds: Set<BoneId?>, definition: CompiledSkeleton): Set<BoneId> = definition.candidateBones
|
||||
.filterTo(mutableSetOf()) { candidate -> definition.candidateSourcesOf(candidate).any { it in trackedBoneIds } }
|
||||
|
||||
/** Hands each bone to the best output that is on and can take it, so nothing is sent twice. */
|
||||
fun computeAutomaticRoutes(candidateBones: Set<BodyPart>, outputStates: OutputStates, registry: BoneRegistry): Routes {
|
||||
fun computeAutomaticRoutes(candidateBones: Set<BoneId>, outputStates: OutputStates, definition: CompiledSkeleton): Routes {
|
||||
val chain = PRIORITY_CHAIN.filter { isActive(outputStates, it) }
|
||||
return candidateBones
|
||||
.mapNotNull { bone -> chain.firstOrNull { bone in acceptedBones(it) }?.let { output -> registry[bone]?.let { it to setOf(output) } } }
|
||||
.mapNotNull { bone -> chain.firstOrNull { bone in acceptedBones(it, definition) }?.let { output -> bone to setOf(output) } }
|
||||
.toMap()
|
||||
}
|
||||
@@ -23,21 +23,6 @@ import solarxr_protocol.datatypes.DeviceOrigin
|
||||
import solarxr_protocol.driver_protocol.BoneBatteryUpdate
|
||||
import solarxr_protocol.driver_protocol.SkeletonUpdate
|
||||
|
||||
val DRIVER_SUPPORTED_BONES = setOf(
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.LEFT_UPPER_ARM,
|
||||
BodyPart.RIGHT_UPPER_ARM,
|
||||
BodyPart.HIP,
|
||||
BodyPart.LEFT_UPPER_LEG,
|
||||
BodyPart.RIGHT_UPPER_LEG,
|
||||
BodyPart.LEFT_FOOT,
|
||||
BodyPart.RIGHT_FOOT,
|
||||
BodyPart.LEFT_SHOULDER,
|
||||
BodyPart.RIGHT_SHOULDER,
|
||||
BodyPart.LEFT_HAND,
|
||||
BodyPart.RIGHT_HAND,
|
||||
)
|
||||
|
||||
class DriverOutgoingTrackersBehaviour(
|
||||
private val appContext: AppContextProvider,
|
||||
) : SolarXRBridgeBehaviour {
|
||||
|
||||
@@ -2,7 +2,7 @@ package dev.slimevr.solarxr.rpc
|
||||
|
||||
import dev.slimevr.AppContextProvider
|
||||
import dev.slimevr.bones.BoneId
|
||||
import dev.slimevr.bones.BoneRegistry
|
||||
import dev.slimevr.bones.CompiledSkeleton
|
||||
import dev.slimevr.config.SettingsActions
|
||||
import dev.slimevr.routing.OutputStates
|
||||
import dev.slimevr.routing.Routes
|
||||
@@ -30,26 +30,21 @@ import solarxr_protocol.rpc.RoutingOutput
|
||||
import solarxr_protocol.rpc.RoutingOutputState
|
||||
import solarxr_protocol.rpc.RoutingOutputStatus
|
||||
|
||||
// Every bone any output can take gets a row, so the GUI can draw the whole table
|
||||
// from the response alone.
|
||||
private val ROUTABLE_BONES = RoutingOutput.entries.flatMapTo(mutableSetOf()) { acceptedBones(it) }
|
||||
|
||||
private fun buildResponse(
|
||||
automatic: Boolean,
|
||||
routes: Routes,
|
||||
outputStates: OutputStates,
|
||||
registry: BoneRegistry,
|
||||
routableBones: Set<BoneId>,
|
||||
definition: CompiledSkeleton,
|
||||
) = BoneRoutingSettingsResponse(
|
||||
automatic = automatic,
|
||||
routes = ROUTABLE_BONES.mapNotNull { bone -> registry[bone] }.map { boneId ->
|
||||
BoneRoute(boneId = boneId.value, outputs = routes[boneId].orEmpty().toList())
|
||||
},
|
||||
routes = routableBones.map { boneId -> BoneRoute(boneId = boneId.value, outputs = routes[boneId].orEmpty().toList()) },
|
||||
outputs = RoutingOutput.entries.map { output ->
|
||||
RoutingOutputStatus(
|
||||
output = output,
|
||||
accepts = acceptedBones(output).mapNotNull { registry[it]?.value },
|
||||
requires = requiredBones(output).mapNotNull { registry[it]?.value },
|
||||
overridable = overridableBones(output).mapNotNull { registry[it]?.value },
|
||||
accepts = acceptedBones(output, definition).map { it.value },
|
||||
requires = requiredBones(output, definition).map { it.value },
|
||||
overridable = overridableBones(output, definition).map { it.value },
|
||||
conflicts = conflictingOutputs(output).toList(),
|
||||
state = outputStates[output] ?: RoutingOutputState.UNSUPPORTED,
|
||||
)
|
||||
@@ -62,12 +57,15 @@ class BoneRoutingBehaviour(
|
||||
private val settings = appContext.config.settings
|
||||
|
||||
override fun observe(receiver: SolarXRBridge) {
|
||||
val registry = appContext.bones.current
|
||||
val definition = appContext.skeleton.definition
|
||||
// Every bone any output can take gets a row, so the GUI can draw the whole table
|
||||
// from the response alone.
|
||||
val routableBones = RoutingOutput.entries.flatMapTo(mutableSetOf()) { acceptedBones(it, definition) }
|
||||
val responses = combine(
|
||||
settings.context.state.map { it.data.boneRoutingConfig.automatic }.distinctUntilChanged(),
|
||||
intendedRoutesFlow(appContext),
|
||||
outputStatesFlow(appContext),
|
||||
) { automatic, routes, outputStates -> buildResponse(automatic, routes, outputStates, registry) }
|
||||
) { automatic, routes, outputStates -> buildResponse(automatic, routes, outputStates, routableBones, definition) }
|
||||
.distinctUntilChanged()
|
||||
|
||||
receiver.rpcDispatcher.on<BoneRoutingSettingsRequest> {
|
||||
@@ -95,7 +93,7 @@ class BoneRoutingBehaviour(
|
||||
config = boneRoutingConfig,
|
||||
automatic = req.automatic,
|
||||
routes = requested,
|
||||
registry = registry,
|
||||
definition = definition,
|
||||
),
|
||||
)
|
||||
},
|
||||
|
||||
@@ -73,9 +73,6 @@ val BODY_PART_TO_UNITY_BONE: BodyPartMap<Array<String>> = BodyPartMap(
|
||||
),
|
||||
)
|
||||
|
||||
// Bones VMC can accept. Used by the routing module.
|
||||
val VMC_SUPPORTED_BONES: Set<BodyPart> = BODY_PART_TO_UNITY_BONE.keys
|
||||
|
||||
// HIP-rooted hierarchy. VMC/Unity expects this; our skeleton is HEAD-rooted.
|
||||
// TODO Test with a model that has UPPER_CHEST
|
||||
// and figure out how to deal with it (check if present in VRM?)
|
||||
|
||||
@@ -23,9 +23,6 @@ private val trackerIdsByBodyPart = mapOf(
|
||||
BodyPart.RIGHT_UPPER_ARM to 8,
|
||||
)
|
||||
|
||||
/** Bones VRChat OSC can accept. Used by the routing module. */
|
||||
val VRC_OSC_SUPPORTED_BONES: Set<BodyPart> = trackerIdsByBodyPart.keys
|
||||
|
||||
internal fun buildOutgoingBundle(
|
||||
bones: ComputedSkeleton,
|
||||
routedBones: Set<BodyPart>,
|
||||
|
||||
@@ -7,7 +7,7 @@ import dev.slimevr.resourcepacks.ResourcePackCatalog
|
||||
import dev.slimevr.resourcepacks.ResourcePackParser
|
||||
import io.github.axisangles.ktmath.Vector3
|
||||
import kotlinx.coroutines.test.runTest
|
||||
import solarxr_protocol.datatypes.BodyPart
|
||||
import solarxr_protocol.rpc.RoutingOutput
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertFailsWith
|
||||
@@ -183,6 +183,99 @@ class ResourcePackCompilerTest {
|
||||
assertTrue(error.diagnostics.any { "Unknown bone" in it.message && "rotationFallback" in it.message })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `bundled core pack's driver and VMC accepted sets match the retired hardcoded tables`() = runTest {
|
||||
val core = ResourcePackParser().parse(ClasspathResourcePackSource.core(javaClass.classLoader))
|
||||
val definition = compileResourcePacks(catalog(core))
|
||||
val registry = definition.registry
|
||||
|
||||
val driverBones = setOf(
|
||||
BodyPart.UPPER_CHEST, BodyPart.LEFT_UPPER_ARM, BodyPart.RIGHT_UPPER_ARM, BodyPart.HIP,
|
||||
BodyPart.LEFT_UPPER_LEG, BodyPart.RIGHT_UPPER_LEG, BodyPart.LEFT_FOOT, BodyPart.RIGHT_FOOT,
|
||||
BodyPart.LEFT_SHOULDER, BodyPart.RIGHT_SHOULDER, BodyPart.LEFT_HAND, BodyPart.RIGHT_HAND,
|
||||
).map { registry[it.key]!! }.toSet()
|
||||
assertEquals(driverBones, definition.acceptedBones(RoutingOutput.DRIVER))
|
||||
|
||||
assertEquals(60, definition.acceptedBones(RoutingOutput.VMC).size)
|
||||
assertEquals(definition.acceptedBones(RoutingOutput.VMC), definition.requiredBones(RoutingOutput.VMC))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `bundled core pack's VRChat accepted and required sets grow past the retired hardcoded table`() = runTest {
|
||||
val core = ResourcePackParser().parse(ClasspathResourcePackSource.core(javaClass.classLoader))
|
||||
val definition = compileResourcePacks(catalog(core))
|
||||
val registry = definition.registry
|
||||
|
||||
val oldEight = setOf(
|
||||
BodyPart.HIP,
|
||||
BodyPart.LEFT_FOOT,
|
||||
BodyPart.RIGHT_FOOT,
|
||||
BodyPart.LEFT_UPPER_LEG,
|
||||
BodyPart.RIGHT_UPPER_LEG,
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.LEFT_UPPER_ARM,
|
||||
BodyPart.RIGHT_UPPER_ARM,
|
||||
).map { registry[it.key]!! }.toSet()
|
||||
val accepted = definition.acceptedBones(RoutingOutput.VRC_OSC)
|
||||
assertEquals(19, accepted.size)
|
||||
assertTrue(accepted.containsAll(oldEight))
|
||||
|
||||
assertEquals(setOf(registry[BodyPart.HEAD.key]!!), definition.requiredBones(RoutingOutput.VRC_OSC))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `bundled core pack's overridable bones match the retired hardcoded set`() = runTest {
|
||||
val core = ResourcePackParser().parse(ClasspathResourcePackSource.core(javaClass.classLoader))
|
||||
val definition = compileResourcePacks(catalog(core))
|
||||
val registry = definition.registry
|
||||
assertEquals(setOf(registry[BodyPart.LEFT_HAND.key]!!, registry[BodyPart.RIGHT_HAND.key]!!), definition.overridableBones)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `bundled core pack's candidate bones include the retired table plus every toe`() = runTest {
|
||||
val core = ResourcePackParser().parse(ClasspathResourcePackSource.core(javaClass.classLoader))
|
||||
val definition = compileResourcePacks(catalog(core))
|
||||
val registry = definition.registry
|
||||
|
||||
val oldEight = setOf(
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.LEFT_UPPER_ARM,
|
||||
BodyPart.RIGHT_UPPER_ARM,
|
||||
BodyPart.HIP,
|
||||
BodyPart.LEFT_UPPER_LEG,
|
||||
BodyPart.RIGHT_UPPER_LEG,
|
||||
BodyPart.LEFT_FOOT,
|
||||
BodyPart.RIGHT_FOOT,
|
||||
).map { registry[it.key]!! }.toSet()
|
||||
val toes = setOf(
|
||||
BodyPart.LEFT_BIG_TOE, BodyPart.LEFT_INDEX_TOE, BodyPart.LEFT_MIDDLE_TOE, BodyPart.LEFT_RING_TOE, BodyPart.LEFT_LITTLE_TOE,
|
||||
BodyPart.RIGHT_BIG_TOE, BodyPart.RIGHT_INDEX_TOE, BodyPart.RIGHT_MIDDLE_TOE, BodyPart.RIGHT_RING_TOE, BodyPart.RIGHT_LITTLE_TOE,
|
||||
).map { registry[it.key]!! }.toSet()
|
||||
assertEquals(oldEight + toes, definition.candidateBones)
|
||||
|
||||
val hip = registry[BodyPart.HIP.key]!!
|
||||
assertEquals(
|
||||
setOf(BodyPart.HIP, BodyPart.LOWER_WAIST, BodyPart.UPPER_WAIST, BodyPart.LOWER_CHEST, BodyPart.UPPER_CHEST).map { registry[it.key]!! }.toSet(),
|
||||
definition.candidateSourcesOf(hip).toSet(),
|
||||
)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `compiler reports an unknown bone named in candidateSources`() = runTest {
|
||||
val core = ResourcePackParser().parse(ClasspathResourcePackSource.core(javaClass.classLoader))
|
||||
val user = ResourcePackParser().parse(
|
||||
InMemoryResourcePackSource(
|
||||
mapOf(
|
||||
"manifest.json" to manifest("example:extra"),
|
||||
"data/bones/extra.json" to """{"key":"example:extra","nameKey":"example:bone.extra","parent":"slimevr:head","candidateSources":["example:missing"]}""",
|
||||
"assets/lang/en.json" to """{"example:bone.extra":"Extra bone"}""",
|
||||
),
|
||||
),
|
||||
)
|
||||
val error = assertFailsWith<ResourcePackCompilationException> { compileResourcePacks(catalog(core, user)) }
|
||||
assertTrue(error.diagnostics.any { "Unknown bone" in it.message && "candidateSources" in it.message })
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `compiler includes user-pack bones after the core registry`() = runTest {
|
||||
val core = ResourcePackParser().parse(ClasspathResourcePackSource.core(javaClass.classLoader))
|
||||
|
||||
@@ -1,10 +1,9 @@
|
||||
package dev.slimevr.routing
|
||||
|
||||
import dev.slimevr.bones.BodyPart
|
||||
import dev.slimevr.bones.BoneRegistry
|
||||
import dev.slimevr.solarxr.driver.DRIVER_SUPPORTED_BONES
|
||||
import dev.slimevr.vmc.VMC_SUPPORTED_BONES
|
||||
import dev.slimevr.vrcosc.VRC_OSC_SUPPORTED_BONES
|
||||
import dev.slimevr.bones.BoneId
|
||||
import dev.slimevr.bones.boneId
|
||||
import dev.slimevr.testCompiledSkeleton
|
||||
import solarxr_protocol.rpc.RoutingOutput
|
||||
import solarxr_protocol.rpc.RoutingOutputState
|
||||
import kotlin.test.Test
|
||||
@@ -18,28 +17,31 @@ private fun active(vararg outputs: RoutingOutput): OutputStates = RoutingOutput.
|
||||
|
||||
private val NONE_ACTIVE = active()
|
||||
|
||||
private val DRIVER_SUPPORTED_BONES = testCompiledSkeleton.acceptedBones(RoutingOutput.DRIVER)
|
||||
private val VMC_SUPPORTED_BONES = testCompiledSkeleton.acceptedBones(RoutingOutput.VMC)
|
||||
private val VRC_OSC_SUPPORTED_BONES = testCompiledSkeleton.acceptedBones(RoutingOutput.VRC_OSC)
|
||||
|
||||
/**
|
||||
* Bones a typical full body setup produces. Deliberately includes lower legs, which
|
||||
* no output can take, so the tests also cover candidates being dropped.
|
||||
*/
|
||||
private val COMMON_CANDIDATES = setOf(
|
||||
private val COMMON_CANDIDATES: Set<BoneId> = setOf(
|
||||
BodyPart.HIP,
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.LEFT_UPPER_LEG,
|
||||
BodyPart.RIGHT_UPPER_LEG,
|
||||
BodyPart.LEFT_LOWER_LEG,
|
||||
BodyPart.RIGHT_LOWER_LEG,
|
||||
)
|
||||
).mapTo(mutableSetOf()) { it.boneId }
|
||||
|
||||
class AutomaticRoutesTest {
|
||||
private val registry = BoneRegistry.standard()
|
||||
private val definition = testCompiledSkeleton
|
||||
|
||||
private fun routedTo(routes: Routes, output: RoutingOutput): Set<BodyPart> = routes.filterValues { output in it }.keys.mapNotNullTo(mutableSetOf(), registry::bodyPartOf)
|
||||
private fun routedTo(routes: Routes, output: RoutingOutput): Set<BoneId> = routes.filterValues { output in it }.keys
|
||||
|
||||
private fun computeAutomaticRoutes(candidateBones: Set<BodyPart>, outputStates: OutputStates): Routes = computeAutomaticRoutes(candidateBones, outputStates, registry)
|
||||
private fun computeAutomaticRoutes(candidateBones: Set<BoneId>, outputStates: OutputStates): Routes = computeAutomaticRoutes(candidateBones, outputStates, definition)
|
||||
|
||||
private fun effectiveRoutes(routes: Routes, outputStates: OutputStates): Routes = effectiveRoutes(routes, outputStates, registry)
|
||||
private fun effectiveRoutes(routes: Routes, outputStates: OutputStates): Routes = effectiveRoutes(routes, outputStates, definition)
|
||||
|
||||
@Test
|
||||
fun `the driver alone takes every bone it supports`() {
|
||||
@@ -78,7 +80,7 @@ class AutomaticRoutesTest {
|
||||
fun `a bone neither can take goes nowhere`() {
|
||||
// NECK is VMC only.
|
||||
val routes = computeAutomaticRoutes(
|
||||
setOf(BodyPart.NECK),
|
||||
setOf(BodyPart.NECK.boneId),
|
||||
active(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC),
|
||||
)
|
||||
|
||||
|
||||
@@ -1,27 +1,30 @@
|
||||
package dev.slimevr.routing
|
||||
|
||||
import dev.slimevr.bones.BodyPart
|
||||
import dev.slimevr.bones.BoneId
|
||||
import dev.slimevr.bones.boneId
|
||||
import dev.slimevr.testCompiledSkeleton
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
|
||||
class CandidateBonesTest {
|
||||
@Test
|
||||
fun `Candidate bones are automatically determined based off body parts`() {
|
||||
fun `Candidate bones are automatically determined based off tracked bones`() {
|
||||
data class TestCase(
|
||||
val name: String,
|
||||
val fineBodyParts: Set<BodyPart?>,
|
||||
val trackedBoneIds: Set<BodyPart?>,
|
||||
val expected: Set<BodyPart>,
|
||||
)
|
||||
|
||||
val testCases = listOf(
|
||||
TestCase(
|
||||
name = "no body part",
|
||||
fineBodyParts = emptySet(),
|
||||
trackedBoneIds = emptySet(),
|
||||
expected = emptySet(),
|
||||
),
|
||||
TestCase(
|
||||
name = "upper chest enables upper chest and hip",
|
||||
fineBodyParts = setOf(BodyPart.UPPER_CHEST),
|
||||
trackedBoneIds = setOf(BodyPart.UPPER_CHEST),
|
||||
expected = setOf(
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.HIP,
|
||||
@@ -29,7 +32,7 @@ class CandidateBonesTest {
|
||||
),
|
||||
TestCase(
|
||||
name = "lower chest enables upper chest and hip",
|
||||
fineBodyParts = setOf(BodyPart.LOWER_CHEST),
|
||||
trackedBoneIds = setOf(BodyPart.LOWER_CHEST),
|
||||
expected = setOf(
|
||||
BodyPart.UPPER_CHEST,
|
||||
BodyPart.HIP,
|
||||
@@ -37,49 +40,49 @@ class CandidateBonesTest {
|
||||
),
|
||||
TestCase(
|
||||
name = "lower waist enables hip",
|
||||
fineBodyParts = setOf(BodyPart.LOWER_WAIST),
|
||||
trackedBoneIds = setOf(BodyPart.LOWER_WAIST),
|
||||
expected = setOf(
|
||||
BodyPart.HIP,
|
||||
),
|
||||
),
|
||||
TestCase(
|
||||
name = "hip enables hip",
|
||||
fineBodyParts = setOf(BodyPart.HIP),
|
||||
trackedBoneIds = setOf(BodyPart.HIP),
|
||||
expected = setOf(
|
||||
BodyPart.HIP,
|
||||
),
|
||||
),
|
||||
TestCase(
|
||||
name = "left lower arm enables left upper arm",
|
||||
fineBodyParts = setOf(BodyPart.LEFT_LOWER_ARM),
|
||||
trackedBoneIds = setOf(BodyPart.LEFT_LOWER_ARM),
|
||||
expected = setOf(
|
||||
BodyPart.LEFT_UPPER_ARM,
|
||||
),
|
||||
),
|
||||
TestCase(
|
||||
name = "right lower arm enables right upper arm",
|
||||
fineBodyParts = setOf(BodyPart.RIGHT_LOWER_ARM),
|
||||
trackedBoneIds = setOf(BodyPart.RIGHT_LOWER_ARM),
|
||||
expected = setOf(
|
||||
BodyPart.RIGHT_UPPER_ARM,
|
||||
),
|
||||
),
|
||||
TestCase(
|
||||
name = "left lower leg enables left foot",
|
||||
fineBodyParts = setOf(BodyPart.LEFT_LOWER_LEG),
|
||||
trackedBoneIds = setOf(BodyPart.LEFT_LOWER_LEG),
|
||||
expected = setOf(
|
||||
BodyPart.LEFT_FOOT,
|
||||
),
|
||||
),
|
||||
TestCase(
|
||||
name = "right lower leg enables right foot",
|
||||
fineBodyParts = setOf(BodyPart.RIGHT_LOWER_LEG),
|
||||
trackedBoneIds = setOf(BodyPart.RIGHT_LOWER_LEG),
|
||||
expected = setOf(
|
||||
BodyPart.RIGHT_FOOT,
|
||||
),
|
||||
),
|
||||
TestCase(
|
||||
name = "multiple automatic trackers",
|
||||
fineBodyParts = setOf(
|
||||
trackedBoneIds = setOf(
|
||||
BodyPart.LEFT_UPPER_ARM,
|
||||
BodyPart.RIGHT_FOOT,
|
||||
BodyPart.HIP,
|
||||
@@ -92,7 +95,7 @@ class CandidateBonesTest {
|
||||
),
|
||||
TestCase(
|
||||
name = "worn hand trackers still enable nothing, hands are overridden by hand",
|
||||
fineBodyParts = setOf(
|
||||
trackedBoneIds = setOf(
|
||||
BodyPart.LEFT_HAND,
|
||||
BodyPart.RIGHT_HAND,
|
||||
),
|
||||
@@ -100,7 +103,7 @@ class CandidateBonesTest {
|
||||
),
|
||||
TestCase(
|
||||
name = "hands alongside automatic trackers leave the automatic ones untouched",
|
||||
fineBodyParts = setOf(
|
||||
trackedBoneIds = setOf(
|
||||
BodyPart.LEFT_FOOT,
|
||||
BodyPart.RIGHT_HAND,
|
||||
),
|
||||
@@ -111,11 +114,12 @@ class CandidateBonesTest {
|
||||
)
|
||||
|
||||
testCases.forEach { case ->
|
||||
val result = determineCandidateBones(case.fineBodyParts)
|
||||
val trackedBoneIds: Set<BoneId?> = case.trackedBoneIds.mapTo(mutableSetOf()) { it?.boneId }
|
||||
val result = determineCandidateBones(trackedBoneIds, testCompiledSkeleton)
|
||||
|
||||
assertEquals(
|
||||
expected = case.expected,
|
||||
actual = result.toSet(),
|
||||
expected = case.expected.mapTo(mutableSetOf()) { it.boneId },
|
||||
actual = result,
|
||||
message = case.name,
|
||||
)
|
||||
}
|
||||
|
||||
@@ -1,16 +1,16 @@
|
||||
package dev.slimevr.routing
|
||||
|
||||
import dev.slimevr.bones.BodyPart
|
||||
import dev.slimevr.bones.BoneRegistry
|
||||
import dev.slimevr.bones.boneId
|
||||
import dev.slimevr.config.BoneRoutingConfig
|
||||
import dev.slimevr.testCompiledSkeleton
|
||||
import solarxr_protocol.rpc.RoutingOutput
|
||||
import solarxr_protocol.rpc.RoutingOutputState
|
||||
import kotlin.test.Test
|
||||
import kotlin.test.assertEquals
|
||||
import kotlin.test.assertNull
|
||||
|
||||
private val registry = BoneRegistry.standard()
|
||||
private val definition = testCompiledSkeleton
|
||||
|
||||
private fun active(vararg outputs: RoutingOutput): OutputStates = RoutingOutput.entries.associateWith {
|
||||
if (it in outputs) RoutingOutputState.ACTIVE else RoutingOutputState.INACTIVE
|
||||
@@ -21,7 +21,7 @@ private val ALL_ON = active(*RoutingOutput.entries.toTypedArray())
|
||||
|
||||
private fun routesOf(vararg pairs: Pair<BodyPart, Set<RoutingOutput>>): Routes = pairs.associate { (bodyPart, outputs) -> bodyPart.boneId to outputs }
|
||||
|
||||
private fun manualRoutesOf(manualRoutes: Map<String, Set<RoutingOutput>>?): Routes = manualRoutesAsBoneIds(manualRoutes, registry)
|
||||
private fun manualRoutesOf(manualRoutes: Map<String, Set<RoutingOutput>>?): Routes = manualRoutesAsBoneIds(manualRoutes, definition)
|
||||
|
||||
private val AUTO_ROUTES = routesOf(
|
||||
BodyPart.HIP to setOf(RoutingOutput.DRIVER),
|
||||
@@ -37,7 +37,7 @@ class ManualRoutesTest {
|
||||
BodyPart.HIP to setOf(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC, RoutingOutput.VMC),
|
||||
)
|
||||
|
||||
val sanitized = effectiveRoutes(routes, active(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC, RoutingOutput.VMC), registry)
|
||||
val sanitized = effectiveRoutes(routes, active(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC, RoutingOutput.VMC), definition)
|
||||
|
||||
assertEquals(
|
||||
setOf(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC, RoutingOutput.VMC),
|
||||
@@ -49,7 +49,7 @@ class ManualRoutesTest {
|
||||
fun `an unavailable output is dropped even when explicitly routed`() {
|
||||
val routes = routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC))
|
||||
|
||||
val sanitized = effectiveRoutes(routes, active(RoutingOutput.VRC_OSC), registry)
|
||||
val sanitized = effectiveRoutes(routes, active(RoutingOutput.VRC_OSC), definition)
|
||||
|
||||
assertEquals(setOf(RoutingOutput.VRC_OSC), sanitized[BodyPart.HIP.boneId])
|
||||
}
|
||||
@@ -58,7 +58,7 @@ class ManualRoutesTest {
|
||||
fun `an output that cannot take the bone is dropped`() {
|
||||
val routes = routesOf(BodyPart.NECK to setOf(RoutingOutput.VRC_OSC, RoutingOutput.VMC))
|
||||
|
||||
val sanitized = effectiveRoutes(routes, active(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC, RoutingOutput.VMC), registry)
|
||||
val sanitized = effectiveRoutes(routes, active(RoutingOutput.DRIVER, RoutingOutput.VRC_OSC, RoutingOutput.VMC), definition)
|
||||
|
||||
assertEquals(setOf(RoutingOutput.VMC), sanitized[BodyPart.NECK.boneId])
|
||||
}
|
||||
@@ -67,7 +67,7 @@ class ManualRoutesTest {
|
||||
fun `a bone left with no output is not kept`() {
|
||||
val routes = routesOf(BodyPart.HIP to setOf(RoutingOutput.VRC_OSC))
|
||||
|
||||
assertEquals(emptyMap(), effectiveRoutes(routes, NONE_ACTIVE, registry))
|
||||
assertEquals(emptyMap(), effectiveRoutes(routes, NONE_ACTIVE, definition))
|
||||
}
|
||||
}
|
||||
|
||||
@@ -84,7 +84,7 @@ class RoutingChangeTest {
|
||||
fun `switching to manual the first time starts from an empty table`() {
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = null)
|
||||
|
||||
val next = applyRoutingChange(config, automatic = false, routes = AUTO_ROUTES, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = false, routes = AUTO_ROUTES, definition = definition)
|
||||
|
||||
assertEquals(false, next.automatic)
|
||||
assertEquals(emptyMap(), next.manualRoutes.orEmpty())
|
||||
@@ -93,28 +93,28 @@ class RoutingChangeTest {
|
||||
@Test
|
||||
fun `switching to manual again keeps the table the user built`() {
|
||||
val built = routesOf(BodyPart.HIP to setOf(RoutingOutput.VRC_OSC))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = built.toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = built.toManualRoutesConfig(definition))
|
||||
|
||||
val next = applyRoutingChange(config, automatic = false, routes = AUTO_ROUTES, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = false, routes = AUTO_ROUTES, definition = definition)
|
||||
|
||||
assertEquals(built, manualRoutesOf(next.manualRoutes))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `editing while manual stores the new table`() {
|
||||
val config = BoneRoutingConfig(automatic = false, manualRoutes = HAND_TABLE.toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = false, manualRoutes = HAND_TABLE.toManualRoutesConfig(definition))
|
||||
val edited = routesOf(BodyPart.HIP to setOf(RoutingOutput.VRC_OSC))
|
||||
|
||||
val next = applyRoutingChange(config, automatic = false, routes = edited, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = false, routes = edited, definition = definition)
|
||||
|
||||
assertEquals(edited, manualRoutesOf(next.manualRoutes))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `switching back to automatic keeps the manual table`() {
|
||||
val config = BoneRoutingConfig(automatic = false, manualRoutes = HAND_TABLE.toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = false, manualRoutes = HAND_TABLE.toManualRoutesConfig(definition))
|
||||
|
||||
val next = applyRoutingChange(config, automatic = true, routes = emptyMap(), registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = true, routes = emptyMap(), definition = definition)
|
||||
|
||||
assertEquals(true, next.automatic)
|
||||
assertEquals(HAND_TABLE, manualRoutesOf(next.manualRoutes))
|
||||
@@ -124,7 +124,7 @@ class RoutingChangeTest {
|
||||
fun `staying automatic never creates a manual table`() {
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = null)
|
||||
|
||||
val next = applyRoutingChange(config, automatic = true, routes = AUTO_ROUTES, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = true, routes = AUTO_ROUTES, definition = definition)
|
||||
|
||||
assertEquals(emptyMap(), next.manualRoutes)
|
||||
}
|
||||
@@ -134,10 +134,10 @@ class RoutingChangeTest {
|
||||
var config = BoneRoutingConfig(automatic = true, manualRoutes = null)
|
||||
val built = AUTO_ROUTES + HAND_TABLE
|
||||
|
||||
config = applyRoutingChange(config, automatic = false, routes = emptyMap(), registry = registry)
|
||||
config = applyRoutingChange(config, automatic = false, routes = built, registry = registry)
|
||||
config = applyRoutingChange(config, automatic = true, routes = emptyMap(), registry = registry)
|
||||
config = applyRoutingChange(config, automatic = false, routes = emptyMap(), registry = registry)
|
||||
config = applyRoutingChange(config, automatic = false, routes = emptyMap(), definition = definition)
|
||||
config = applyRoutingChange(config, automatic = false, routes = built, definition = definition)
|
||||
config = applyRoutingChange(config, automatic = true, routes = emptyMap(), definition = definition)
|
||||
config = applyRoutingChange(config, automatic = false, routes = emptyMap(), definition = definition)
|
||||
|
||||
assertEquals(built, manualRoutesOf(config.manualRoutes))
|
||||
}
|
||||
@@ -150,7 +150,7 @@ class ForcedRoutesTest {
|
||||
BoneRoutingConfig(automatic = false, manualRoutes = emptyMap()),
|
||||
automatic = false,
|
||||
routes = routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER, RoutingOutput.VMC)),
|
||||
registry = registry,
|
||||
definition = definition,
|
||||
)
|
||||
|
||||
assertEquals(routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER)), manualRoutesOf(config.manualRoutes))
|
||||
@@ -162,7 +162,7 @@ class ForcedRoutesTest {
|
||||
BoneRoutingConfig(automatic = false, manualRoutes = emptyMap()),
|
||||
automatic = false,
|
||||
routes = routesOf(BodyPart.NECK to setOf(RoutingOutput.VMC)),
|
||||
registry = registry,
|
||||
definition = definition,
|
||||
)
|
||||
|
||||
assertEquals(emptyMap(), config.manualRoutes)
|
||||
@@ -172,13 +172,13 @@ class ForcedRoutesTest {
|
||||
fun `required bones come back when the routes are resolved`() {
|
||||
val config = BoneRoutingConfig(
|
||||
automatic = false,
|
||||
manualRoutes = routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER)).toManualRoutesConfig(registry),
|
||||
manualRoutes = routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER)).toManualRoutesConfig(definition),
|
||||
)
|
||||
|
||||
val resolved = effectiveRoutes(
|
||||
manualRoutesOf(config.manualRoutes),
|
||||
active(RoutingOutput.DRIVER, RoutingOutput.VMC),
|
||||
registry,
|
||||
definition,
|
||||
)
|
||||
|
||||
assertEquals(setOf(RoutingOutput.DRIVER, RoutingOutput.VMC), resolved[BodyPart.HIP.boneId])
|
||||
@@ -189,14 +189,14 @@ class ForcedRoutesTest {
|
||||
fun `an inactive output does not force anything`() {
|
||||
val config = BoneRoutingConfig(automatic = false, manualRoutes = emptyMap())
|
||||
|
||||
val resolved = effectiveRoutes(manualRoutesOf(config.manualRoutes), active(RoutingOutput.DRIVER), registry)
|
||||
val resolved = effectiveRoutes(manualRoutesOf(config.manualRoutes), active(RoutingOutput.DRIVER), definition)
|
||||
|
||||
assertEquals(emptyMap(), resolved)
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `the page shows required bones ticked whatever is stored`() {
|
||||
val shown = effectiveRoutes(emptyMap(), ALL_ON, registry)
|
||||
val shown = effectiveRoutes(emptyMap(), ALL_ON, definition)
|
||||
|
||||
assertEquals(setOf(RoutingOutput.VMC), shown[BodyPart.NECK.boneId])
|
||||
}
|
||||
@@ -205,8 +205,8 @@ class ForcedRoutesTest {
|
||||
fun `automatic gets required bones through the same step as manual`() {
|
||||
val states = active(RoutingOutput.DRIVER, RoutingOutput.VMC)
|
||||
|
||||
val automatic = effectiveRoutes(computeAutomaticRoutes(setOf(BodyPart.HIP), states, registry), states, registry)
|
||||
val manual = effectiveRoutes(routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER)), states, registry)
|
||||
val automatic = effectiveRoutes(computeAutomaticRoutes(setOf(BodyPart.HIP.boneId), states, definition), states, definition)
|
||||
val manual = effectiveRoutes(routesOf(BodyPart.HIP to setOf(RoutingOutput.DRIVER)), states, definition)
|
||||
|
||||
assertEquals(automatic[BodyPart.NECK.boneId], manual[BodyPart.NECK.boneId])
|
||||
assertEquals(automatic[BodyPart.HIP.boneId], manual[BodyPart.HIP.boneId])
|
||||
@@ -214,44 +214,44 @@ class ForcedRoutesTest {
|
||||
|
||||
@Test
|
||||
fun `everything VMC accepts it also requires`() {
|
||||
assertEquals(acceptedBones(RoutingOutput.VMC), requiredBones(RoutingOutput.VMC))
|
||||
assertEquals(emptySet(), requiredBones(RoutingOutput.DRIVER))
|
||||
assertEquals(acceptedBones(RoutingOutput.VMC, definition), requiredBones(RoutingOutput.VMC, definition))
|
||||
assertEquals(emptySet(), requiredBones(RoutingOutput.DRIVER, definition))
|
||||
}
|
||||
}
|
||||
|
||||
class OverrideRoutesTest {
|
||||
@Test
|
||||
fun `hands are the user's call on the driver only`() {
|
||||
assertEquals(OVERRIDABLE_BONES, overridableBones(RoutingOutput.DRIVER))
|
||||
assertEquals(setOf(BodyPart.LEFT_HAND.boneId, BodyPart.RIGHT_HAND.boneId), overridableBones(RoutingOutput.DRIVER, definition))
|
||||
// Never accepted there.
|
||||
assertEquals(emptySet(), overridableBones(RoutingOutput.VRC_OSC))
|
||||
assertEquals(emptySet(), overridableBones(RoutingOutput.VRC_OSC, definition))
|
||||
// Accepted, but required, so it is always on.
|
||||
assertEquals(emptySet(), overridableBones(RoutingOutput.VMC))
|
||||
assertEquals(emptySet(), overridableBones(RoutingOutput.VMC, definition))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `automatic routes no hands on its own`() {
|
||||
val candidates = determineCandidateBones(setOf(BodyPart.LEFT_HAND, BodyPart.HIP))
|
||||
val candidates = determineCandidateBones(setOf(BodyPart.LEFT_HAND.boneId, BodyPart.HIP.boneId), definition)
|
||||
|
||||
val routes = computeAutomaticRoutes(candidates, ALL_ON, registry)
|
||||
val routes = computeAutomaticRoutes(candidates, ALL_ON, definition)
|
||||
|
||||
assertNull(routes[BodyPart.LEFT_HAND.boneId])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `an override routes the hand while automatic`() {
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = HAND_TABLE.toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = HAND_TABLE.toManualRoutesConfig(definition))
|
||||
|
||||
val routes = computeAutomaticRoutes(determineCandidateBones(emptySet()), ALL_ON, registry) + overrideRoutes(config, registry)
|
||||
val routes = computeAutomaticRoutes(determineCandidateBones(emptySet(), definition), ALL_ON, definition) + overrideRoutes(config, definition)
|
||||
|
||||
assertEquals(setOf(RoutingOutput.DRIVER), routes[BodyPart.LEFT_HAND.boneId])
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `only the overridable bones of a stored table count as overrides`() {
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = (AUTO_ROUTES + HAND_TABLE).toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = (AUTO_ROUTES + HAND_TABLE).toManualRoutesConfig(definition))
|
||||
|
||||
assertEquals(HAND_TABLE, overrideRoutes(config, registry))
|
||||
assertEquals(HAND_TABLE, overrideRoutes(config, definition))
|
||||
}
|
||||
|
||||
@Test
|
||||
@@ -262,7 +262,7 @@ class OverrideRoutesTest {
|
||||
config,
|
||||
automatic = true,
|
||||
routes = routesOf(BodyPart.LEFT_HAND to setOf(RoutingOutput.VMC)),
|
||||
registry = registry,
|
||||
definition = definition,
|
||||
)
|
||||
|
||||
assertEquals(emptyMap(), next.manualRoutes)
|
||||
@@ -272,7 +272,7 @@ class OverrideRoutesTest {
|
||||
fun `editing while automatic stores the override and nothing else`() {
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = null)
|
||||
|
||||
val next = applyRoutingChange(config, automatic = true, routes = AUTO_ROUTES + HAND_TABLE, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = true, routes = AUTO_ROUTES + HAND_TABLE, definition = definition)
|
||||
|
||||
assertEquals(HAND_TABLE, manualRoutesOf(next.manualRoutes))
|
||||
}
|
||||
@@ -280,18 +280,18 @@ class OverrideRoutesTest {
|
||||
@Test
|
||||
fun `editing while automatic leaves a stored manual table alone`() {
|
||||
val stored = routesOf(BodyPart.HIP to setOf(RoutingOutput.VRC_OSC))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = stored.toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = stored.toManualRoutesConfig(definition))
|
||||
|
||||
val next = applyRoutingChange(config, automatic = true, routes = HAND_TABLE, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = true, routes = HAND_TABLE, definition = definition)
|
||||
|
||||
assertEquals(stored + HAND_TABLE, manualRoutesOf(next.manualRoutes))
|
||||
}
|
||||
|
||||
@Test
|
||||
fun `dropping the hand from the request clears the override`() {
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = HAND_TABLE.toManualRoutesConfig(registry))
|
||||
val config = BoneRoutingConfig(automatic = true, manualRoutes = HAND_TABLE.toManualRoutesConfig(definition))
|
||||
|
||||
val next = applyRoutingChange(config, automatic = true, routes = AUTO_ROUTES, registry = registry)
|
||||
val next = applyRoutingChange(config, automatic = true, routes = AUTO_ROUTES, definition = definition)
|
||||
|
||||
assertEquals(emptyMap(), next.manualRoutes)
|
||||
}
|
||||
@@ -300,10 +300,10 @@ class OverrideRoutesTest {
|
||||
fun `the override survives a round trip through manual`() {
|
||||
var config = BoneRoutingConfig(automatic = true, manualRoutes = null)
|
||||
|
||||
config = applyRoutingChange(config, automatic = true, routes = HAND_TABLE, registry = registry)
|
||||
config = applyRoutingChange(config, automatic = false, routes = emptyMap(), registry = registry)
|
||||
config = applyRoutingChange(config, automatic = true, routes = emptyMap(), registry = registry)
|
||||
config = applyRoutingChange(config, automatic = true, routes = HAND_TABLE, definition = definition)
|
||||
config = applyRoutingChange(config, automatic = false, routes = emptyMap(), definition = definition)
|
||||
config = applyRoutingChange(config, automatic = true, routes = emptyMap(), definition = definition)
|
||||
|
||||
assertEquals(setOf(RoutingOutput.DRIVER), overrideRoutes(config, registry)[BodyPart.LEFT_HAND.boneId])
|
||||
assertEquals(setOf(RoutingOutput.DRIVER), overrideRoutes(config, definition)[BodyPart.LEFT_HAND.boneId])
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user