diff --git a/gui/src/components/TrackingPauseButton.tsx b/gui/src/components/TrackingPauseButton.tsx index 3e2eb4e0e..8b7c0a041 100644 --- a/gui/src/components/TrackingPauseButton.tsx +++ b/gui/src/components/TrackingPauseButton.tsx @@ -1,6 +1,11 @@ import { useLocalization } from '@fluent/react'; import { useState } from 'react'; -import { SetPauseTrackingRequestT, RpcMessage } from 'solarxr-protocol'; +import { + SetPauseTrackingRequestT, + RpcMessage, + TrackingPauseStateResponseT, + TrackingPauseStateRequestT, +} from 'solarxr-protocol'; import { useWebsocketAPI } from '@/hooks/websocket-api'; import { BigButton } from './commons/BigButton'; import { PlayIcon } from './commons/icon/PlayIcon'; @@ -10,16 +15,26 @@ export function TrackingPauseButton( props: React.HTMLAttributes ) { const { l10n } = useLocalization(); - const { sendRPCPacket } = useWebsocketAPI(); + const { useRPCPacket, sendRPCPacket } = useWebsocketAPI(); const [trackingPause, setTrackingPause] = useState(false); const toggleTracking = () => { - const pause = new SetPauseTrackingRequestT(); - pause.pauseTracking = !trackingPause; - setTrackingPause(pause.pauseTracking); + const pause = new SetPauseTrackingRequestT(!trackingPause); sendRPCPacket(RpcMessage.SetPauseTrackingRequest, pause); }; + useRPCPacket( + RpcMessage.TrackingPauseStateResponse, + (data: TrackingPauseStateResponseT) => { + setTrackingPause(data.trackingPaused); + } + ); + + sendRPCPacket( + RpcMessage.TrackingPauseStateRequest, + new TrackingPauseStateRequestT() + ); + return ( { + server + .scheduleTogglePauseTracking( + resetSourceName, + this.config.getPauseTrackingDelay() + ); + } } } } diff --git a/server/core/src/main/java/dev/slimevr/VRServer.kt b/server/core/src/main/java/dev/slimevr/VRServer.kt index b46c5882d..2f4e9767d 100644 --- a/server/core/src/main/java/dev/slimevr/VRServer.kt +++ b/server/core/src/main/java/dev/slimevr/VRServer.kt @@ -35,6 +35,7 @@ import java.util.* import java.util.concurrent.LinkedBlockingQueue import java.util.concurrent.atomic.AtomicInteger import java.util.function.Consumer +import kotlin.concurrent.schedule typealias SteamBridgeProvider = ( server: VRServer, @@ -297,31 +298,42 @@ class VRServer @JvmOverloads constructor( queueTask { humanPoseManager.clearTrackersMounting(resetSourceName) } } + fun setPauseTracking(pauseTracking: Boolean, sourceName: String?) { + queueTask { humanPoseManager.setPauseTracking(pauseTracking, sourceName) } + } + + fun togglePauseTracking(sourceName: String?) { + queueTask { humanPoseManager.togglePauseTracking(sourceName) } + } + fun scheduleResetTrackersFull(resetSourceName: String?, delay: Long) { - val resetTask: TimerTask = object : TimerTask() { - override fun run() { - queueTask { humanPoseManager.resetTrackersFull(resetSourceName) } - } + timer.schedule(delay) { + queueTask { humanPoseManager.resetTrackersFull(resetSourceName) } } - timer.schedule(resetTask, delay) } fun scheduleResetTrackersYaw(resetSourceName: String?, delay: Long) { - val yawResetTask: TimerTask = object : TimerTask() { - override fun run() { - queueTask { humanPoseManager.resetTrackersYaw(resetSourceName) } - } + timer.schedule(delay) { + queueTask { humanPoseManager.resetTrackersYaw(resetSourceName) } } - timer.schedule(yawResetTask, delay) } fun scheduleResetTrackersMounting(resetSourceName: String?, delay: Long) { - val resetMountingTask: TimerTask = object : TimerTask() { - override fun run() { - queueTask { humanPoseManager.resetTrackersMounting(resetSourceName) } - } + timer.schedule(delay) { + queueTask { humanPoseManager.resetTrackersMounting(resetSourceName) } + } + } + + fun scheduleSetPauseTracking(pauseTracking: Boolean, sourceName: String?, delay: Long) { + timer.schedule(delay) { + queueTask { humanPoseManager.setPauseTracking(pauseTracking, sourceName) } + } + } + + fun scheduleTogglePauseTracking(sourceName: String?, delay: Long) { + timer.schedule(delay) { + queueTask { humanPoseManager.togglePauseTracking(sourceName) } } - timer.schedule(resetMountingTask, delay) } fun setLegTweaksEnabled(value: Boolean) { diff --git a/server/core/src/main/java/dev/slimevr/config/KeybindingsConfig.java b/server/core/src/main/java/dev/slimevr/config/KeybindingsConfig.java index 198552f54..65cfb72bf 100644 --- a/server/core/src/main/java/dev/slimevr/config/KeybindingsConfig.java +++ b/server/core/src/main/java/dev/slimevr/config/KeybindingsConfig.java @@ -8,12 +8,16 @@ public class KeybindingsConfig { private String mountingResetBinding = "CTRL+ALT+SHIFT+I"; + private String pauseTrackingBinding = "CTRL+ALT+SHIFT+O"; + private long fullResetDelay = 0L; private long yawResetDelay = 0L; private long mountingResetDelay = 0L; + private long pauseTrackingDelay = 0L; + public KeybindingsConfig() { } @@ -30,6 +34,10 @@ public class KeybindingsConfig { return mountingResetBinding; } + public String getPauseTrackingBinding() { + return pauseTrackingBinding; + } + public long getFullResetDelay() { return fullResetDelay; } @@ -53,4 +61,12 @@ public class KeybindingsConfig { public void setMountingResetDelay(long delay) { mountingResetDelay = delay; } + + public long getPauseTrackingDelay() { + return pauseTrackingDelay; + } + + public void setPauseTrackingDelay(long delay) { + pauseTrackingDelay = delay; + } } diff --git a/server/core/src/main/java/dev/slimevr/protocol/rpc/RPCHandler.java b/server/core/src/main/java/dev/slimevr/protocol/rpc/RPCHandler.java index 986582211..9cce05c42 100644 --- a/server/core/src/main/java/dev/slimevr/protocol/rpc/RPCHandler.java +++ b/server/core/src/main/java/dev/slimevr/protocol/rpc/RPCHandler.java @@ -14,6 +14,7 @@ import dev.slimevr.protocol.rpc.settings.RPCSettingsHandler; import dev.slimevr.protocol.rpc.setup.RPCTapSetupHandler; import dev.slimevr.protocol.rpc.setup.RPCUtil; import dev.slimevr.protocol.rpc.status.RPCStatusHandler; +import dev.slimevr.protocol.rpc.trackingpause.RPCTrackingPause; import dev.slimevr.tracking.processor.config.SkeletonConfigOffsets; import dev.slimevr.tracking.trackers.Tracker; import dev.slimevr.tracking.trackers.TrackerPosition; @@ -46,6 +47,7 @@ public class RPCHandler extends ProtocolHandler { new RPCTapSetupHandler(this, api); new RPCStatusHandler(this, api); new RPCAutoBoneHandler(this, api); + new RPCTrackingPause(this, api); registerPacketListener(RpcMessage.ResetRequest, this::onResetRequest); registerPacketListener( @@ -379,7 +381,7 @@ public class RPCHandler extends ProtocolHandler { if (req == null) return; - this.api.server.humanPoseManager.setPauseTracking(req.pauseTracking()); + this.api.server.humanPoseManager.setPauseTracking(req.pauseTracking(), resetSourceName); } public void onHeightRequest(GenericConnection conn, RpcMessageHeader messageHeader) { diff --git a/server/core/src/main/java/dev/slimevr/protocol/rpc/trackingpause/RPCTrackingPause.kt b/server/core/src/main/java/dev/slimevr/protocol/rpc/trackingpause/RPCTrackingPause.kt new file mode 100644 index 000000000..1e57a75d7 --- /dev/null +++ b/server/core/src/main/java/dev/slimevr/protocol/rpc/trackingpause/RPCTrackingPause.kt @@ -0,0 +1,53 @@ +package dev.slimevr.protocol.rpc.trackingpause + +import com.google.flatbuffers.FlatBufferBuilder +import dev.slimevr.protocol.GenericConnection +import dev.slimevr.protocol.ProtocolAPI +import dev.slimevr.protocol.rpc.RPCHandler +import dev.slimevr.trackingpause.TrackingPauseListener +import solarxr_protocol.rpc.RpcMessage +import solarxr_protocol.rpc.RpcMessageHeader +import solarxr_protocol.rpc.TrackingPauseStateResponse +import java.nio.ByteBuffer + +class RPCTrackingPause(private val rpcHandler: RPCHandler, private val api: ProtocolAPI) : TrackingPauseListener { + + private val currentPauseState + get() = api.server.humanPoseManager.skeleton.getPauseTracking() + + init { + rpcHandler.registerPacketListener( + RpcMessage.TrackingPauseStateRequest, + ::onTrackingPauseStateRequest + ) + + // HumanPoseManager might not be immediately available, so queue the server + // to register the listener once it's fully initialized + api.server.queueTask { + api.server.humanPoseManager.trackingPauseHandler.addListener(this) + } + } + + private fun getPauseStateResponse(trackingPaused: Boolean): ByteBuffer { + val fbb = FlatBufferBuilder(32) + val state = TrackingPauseStateResponse.createTrackingPauseStateResponse(fbb, trackingPaused) + val outbound = rpcHandler.createRPCMessage(fbb, RpcMessage.TrackingPauseStateResponse, state) + fbb.finish(outbound) + return fbb.dataBuffer() + } + + private fun onTrackingPauseStateRequest(conn: GenericConnection, messageHeader: RpcMessageHeader) { + conn.send(getPauseStateResponse(currentPauseState)) + } + + override fun onTrackingPause(trackingPaused: Boolean) { + val pauseState = getPauseStateResponse(trackingPaused) + forAllListeners { it.send(pauseState) } + } + + private fun forAllListeners(action: (GenericConnection) -> Unit) { + api.apiServers.forEach { + it.apiConnections.forEach(action) + } + } +} diff --git a/server/core/src/main/java/dev/slimevr/tracking/processor/HumanPoseManager.java b/server/core/src/main/java/dev/slimevr/tracking/processor/HumanPoseManager.java index 90edf3cbe..b9eb1dfd8 100644 --- a/server/core/src/main/java/dev/slimevr/tracking/processor/HumanPoseManager.java +++ b/server/core/src/main/java/dev/slimevr/tracking/processor/HumanPoseManager.java @@ -12,6 +12,7 @@ import dev.slimevr.tracking.trackers.Tracker; import dev.slimevr.tracking.trackers.TrackerPosition; import dev.slimevr.tracking.trackers.TrackerRole; import dev.slimevr.tracking.trackers.TrackerStatus; +import dev.slimevr.trackingpause.TrackingPauseHandler; import dev.slimevr.util.ann.VRServerThread; import io.eiren.util.ann.ThreadSafe; import io.eiren.util.collections.FastList; @@ -36,6 +37,7 @@ public class HumanPoseManager { private final SkeletonConfigManager skeletonConfigManager; private HumanSkeleton skeleton; private long timeAtLastReset; + public final TrackingPauseHandler trackingPauseHandler = new TrackingPauseHandler(); // #region Constructors private HumanPoseManager() { @@ -813,9 +815,15 @@ public class HumanPoseManager { } // #endregion - public void setPauseTracking(boolean pauseTracking) { + public void setPauseTracking(boolean pauseTracking, String sourceName) { if (isSkeletonPresent()) - skeleton.setPauseTracking(pauseTracking); + skeleton.setPauseTracking(pauseTracking, sourceName); + } + + public boolean togglePauseTracking(String sourceName) { + if (isSkeletonPresent()) + return skeleton.togglePauseTracking(sourceName); + return false; } // #endregion } diff --git a/server/core/src/main/java/dev/slimevr/tracking/processor/skeleton/HumanSkeleton.kt b/server/core/src/main/java/dev/slimevr/tracking/processor/skeleton/HumanSkeleton.kt index 630a3eafa..f9c2a680c 100644 --- a/server/core/src/main/java/dev/slimevr/tracking/processor/skeleton/HumanSkeleton.kt +++ b/server/core/src/main/java/dev/slimevr/tracking/processor/skeleton/HumanSkeleton.kt @@ -1210,12 +1210,21 @@ class HumanSkeleton( return pauseTracking } - fun setPauseTracking(pauseTracking: Boolean) { + fun setPauseTracking(pauseTracking: Boolean, sourceName: String?) { if (!pauseTracking && this.pauseTracking) { // If unpausing tracking, clear the legtweaks buffer legTweaks.resetBuffer() } this.pauseTracking = pauseTracking + LogManager.info(String.format("[HumanSkeleton] ${if (pauseTracking) "Pause" else "Unpause"} tracking (%s)", sourceName)) + // Report the new state of tracking pause + humanPoseManager.trackingPauseHandler.sendTrackingPauseState(pauseTracking) + } + + fun togglePauseTracking(sourceName: String?): Boolean { + val newState = !pauseTracking + setPauseTracking(newState, sourceName) + return newState } companion object { diff --git a/server/core/src/main/java/dev/slimevr/trackingpause/TrackingPauseHandler.kt b/server/core/src/main/java/dev/slimevr/trackingpause/TrackingPauseHandler.kt new file mode 100644 index 000000000..833dc25d4 --- /dev/null +++ b/server/core/src/main/java/dev/slimevr/trackingpause/TrackingPauseHandler.kt @@ -0,0 +1,19 @@ +package dev.slimevr.trackingpause + +import java.util.concurrent.CopyOnWriteArrayList + +class TrackingPauseHandler { + private val listeners: MutableList = CopyOnWriteArrayList() + + fun sendTrackingPauseState(trackingPaused: Boolean) { + listeners.forEach { it.onTrackingPause(trackingPaused) } + } + + fun addListener(listener: TrackingPauseListener) { + listeners.add(listener) + } + + fun removeListener(listener: TrackingPauseListener) { + listeners.removeIf { it == listener } + } +} diff --git a/server/core/src/main/java/dev/slimevr/trackingpause/TrackingPauseListener.kt b/server/core/src/main/java/dev/slimevr/trackingpause/TrackingPauseListener.kt new file mode 100644 index 000000000..26182c04a --- /dev/null +++ b/server/core/src/main/java/dev/slimevr/trackingpause/TrackingPauseListener.kt @@ -0,0 +1,5 @@ +package dev.slimevr.trackingpause + +interface TrackingPauseListener { + fun onTrackingPause(trackingPaused: Boolean) +} diff --git a/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.java b/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.java index 48e6e079f..7a59c03e6 100644 --- a/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.java +++ b/server/desktop/src/main/java/dev/slimevr/desktop/platform/ProtobufBridge.java @@ -205,6 +205,9 @@ public abstract class ProtobufBridge implements ISteamVRBridge { // TODO : Check pose field VRServer.Companion.getInstance().resetTrackersFull(resetSourceName); case "fast_reset" -> VRServer.Companion.getInstance().resetTrackersYaw(resetSourceName); + case "pause_tracking" -> VRServer.Companion + .getInstance() + .togglePauseTracking(resetSourceName); } } diff --git a/solarxr-protocol b/solarxr-protocol index 76317568f..cec1f04c4 160000 --- a/solarxr-protocol +++ b/solarxr-protocol @@ -1 +1 @@ -Subproject commit 76317568f7f2ee3937e6bca08ef26328a4e887a0 +Subproject commit cec1f04c48d3fd6a999225b656ea616aca2f23e5