Datafeed almost done

This commit is contained in:
lucas lelievre committed 2022-04-12 09:07:18 +02:00
1 parent 7ab9a37989
commit 52fa670293
21 files changed
+4865 -124

No files matched your search

@@ -9,8 +9,18 @@ public class ConnectionContext {
private final List<DataFeedConfigT> dataFeedConfigList = new ArrayList<>();
// I did it in a separate array because it was more convenient than making a parent object of the DataFeedConfigT
// idk if it should be a concern or not, i think it is fine tbh
// Futurabeast
private final List<Long> dataFeedTimers = new ArrayList<>();
public List<DataFeedConfigT> getDataFeedConfigList() {
return dataFeedConfigList;
}
public List<Long> getDataFeedTimers() {
return dataFeedTimers;
}
}
@@ -0,0 +1,159 @@
package dev.slimevr.websocketapi;
import com.google.flatbuffers.FlatBufferBuilder;
import com.jme3.math.Quaternion;
import com.jme3.math.Vector3f;
import dev.slimevr.vr.trackers.IMUTracker;
import dev.slimevr.vr.trackers.udp.TrackerUDPConnection;
import slimevr_protocol.data_feed.DataFeedConfigT;
import slimevr_protocol.data_feed.DataFeedUpdate;
import slimevr_protocol.data_feed.device_data.DeviceData;
import slimevr_protocol.data_feed.device_data.DeviceDataMaskT;
import slimevr_protocol.data_feed.tracker.*;
import slimevr_protocol.datatypes.DeviceId;
import slimevr_protocol.datatypes.Temperature;
import slimevr_protocol.datatypes.TrackerId;
import slimevr_protocol.datatypes.hardware_info.HardwareInfo;
import slimevr_protocol.datatypes.hardware_info.HardwareStatus;
import slimevr_protocol.datatypes.math.Quat;
import slimevr_protocol.datatypes.math.Vec3f;
import java.util.ArrayList;
import java.util.List;
public class DataFeedBuilder {
public static int createHardwareInfo(FlatBufferBuilder fbb, TrackerUDPConnection device) {
IMUTracker tracker = device.sensors.get(0);
HardwareInfo.startHardwareInfo(fbb);
// BRUH MOMENT
//TODO need support: HardwareInfo.addFirmwareVersion(fbb, firmwareVersionOffset);
//TODO need support: HardwareInfo.addHardwareRevision(fbb, hardwareRevisionOffset);
//TODO need support: HardwareInfo.addManufacturer(fbb, device.m);
//TODO need support: HardwareInfo.addDisplayName(fbb, de);
//TODO need support: HardwareInfo.addHardwareAddress(fbb, tracker.);
//TODO need support: HardwareInfo.addMcuId(device);
return HardwareInfo.endHardwareInfo(fbb);
}
public static int createTrackerId(FlatBufferBuilder fbb, int trackerNum, int deviceId) {
TrackerId.startTrackerId(fbb);
TrackerId.addTrackerNum(fbb, trackerNum);
TrackerId.addDeviceId(fbb, DeviceId.createDeviceId(fbb, deviceId));
return TrackerId.endTrackerId(fbb);
}
public static int createTrackerDataComponents(FlatBufferBuilder fbb, TrackerDataMaskT mask, IMUTracker tracker) {
List<Integer> dataOffsets = new ArrayList<>(TrackerDataComponent.names.length);
for (int index = 0; index < TrackerDataComponent.names.length; index++) {
if (index == TrackerDataComponent.info && mask.getInfo()) {
// Vector3f pos = new Vector3f();
// tracker.getPosition(pos);
// dataOffsets[index] = TrackerInfo.;
}
if (index == TrackerDataComponent.position && mask.getPosition()) {
Vector3f pos = new Vector3f();
tracker.getPosition(pos);
dataOffsets.add(
TrackerDataComponentW.createTrackerDataComponentW(
fbb,
TrackerDataComponent.position,
Vec3f.createVec3f(fbb, pos.x, pos.y, pos.z)
)
);
}
if (index == TrackerDataComponent.rotation && mask.getRotation()) {
Quaternion quaternion = new Quaternion();
tracker.getRotation(quaternion);
dataOffsets.add(
TrackerDataComponentW.createTrackerDataComponentW(
fbb,
TrackerDataComponent.rotation,
Quat.createQuat(fbb,
quaternion.getX(),
quaternion.getY(),
quaternion.getZ(),
quaternion.getW()
)
)
);
}
if (index == TrackerDataComponent.temp && mask.getTemp()) {
dataOffsets.add(TrackerDataComponentW.createTrackerDataComponentW(fbb, TrackerDataComponent.temp, Temperature.createTemperature(fbb, tracker.temperature)));
}
}
TrackerData.startDataVector(fbb, dataOffsets.size());
dataOffsets.forEach((offset) -> {
TrackerData.addData(fbb, offset);
});
return fbb.endVector();
}
public static int createTrackersData(FlatBufferBuilder fbb, DeviceDataMaskT mask, TrackerUDPConnection device, int deviceId) {
if (mask.getTrackerData() == null) return -1;
int[] sensorsOffsets = new int[device.sensors.size()];
device.sensors.forEach((key, value) -> {
int trackerIdOffset = DataFeedBuilder.createTrackerId(fbb, key, deviceId);
int dataOffset = DataFeedBuilder.createTrackerDataComponents(fbb, mask.getTrackerData(), value);
sensorsOffsets[key] = TrackerData.createTrackerData(fbb, trackerIdOffset, dataOffset);
});
return TrackerData.createDataVector(fbb, sensorsOffsets);
}
public static int createDeviceData(FlatBufferBuilder fbb, int id, DeviceDataMaskT mask, TrackerUDPConnection device) {
if (!mask.getDeviceData()) return -1;
IMUTracker tracker = device.sensors.get(0);
if (tracker == null) return -1;
int nameOffset = fbb.createString(device.name);
int hardwareDataOffset = HardwareStatus.createHardwareStatus(
fbb,
tracker.getStatus().id,
(int) tracker.getTPS(),
tracker.ping,
(short) tracker.signalStrength,
tracker.temperature,
tracker.getBatteryVoltage(),
(int) tracker.getBatteryLevel(),
-1
);
int hardwareInfoOffset = DataFeedBuilder.createHardwareInfo(fbb, device);
int trackersOffset = DataFeedBuilder.createTrackersData(fbb, mask, device, id);
DeviceData.startDeviceData(fbb);
DeviceData.addCustomName(fbb, nameOffset);
DeviceData.addId(fbb, DeviceId.createDeviceId(fbb, id));
DeviceData.addHardwareStatus(fbb, hardwareDataOffset);
DeviceData.addHardwareInfo(fbb, hardwareInfoOffset);
DeviceData.addTrackers(fbb, trackersOffset);
return DeviceData.endDeviceData(fbb);
}
public static int createDevicesData(FlatBufferBuilder fbb, DataFeedConfigT config, List<TrackerUDPConnection> devices) {
if (config.getDataMask() == null) return -1;
DeviceDataMaskT deviceDataMaskT = config.getDataMask();
int[] devicesDataOffsets = new int[devices.size()];
for (int i = 0; i < devices.size(); i++) {
TrackerUDPConnection device = devices.get(i);
devicesDataOffsets[i] = DataFeedBuilder.createDeviceData(fbb, i, deviceDataMaskT, device);
}
return DataFeedUpdate.createDevicesVector(fbb, devicesDataOffsets);
}
}
@@ -1,103 +1,101 @@
package dev.slimevr.websocketapi;
import com.google.flatbuffers.FlatBufferBuilder;
import dev.slimevr.vr.trackers.udp.TrackerUDPConnection;
import slimevr_protocol.InboundPacket;
import slimevr_protocol.InboundUnion;
import io.eiren.util.logging.LogManager;
import slimevr_protocol.MessageBundle;
import slimevr_protocol.data_feed.*;
import slimevr_protocol.datatypes.hardware_info.FirmwareInfo;
import slimevr_protocol.datatypes.hardware_info.FirmwareInfoMaskT;
import java.util.function.BiConsumer;
import java.nio.ByteBuffer;
import java.util.List;
public class DataFeedHandler {
public class DataFeedHandler extends ProtocolHandler<DataFeedMessageHeader> {
private final ProtocolAPI api;
public DataFeedHandler(ProtocolAPI api) {
this.api = api;
api.registerPacketListener(InboundUnion.slimevr_protocol_data_feed_DataFeedRequest, this::onDataFeedRequest);
api.registerPacketListener(InboundUnion.slimevr_protocol_data_feed_PollDataFeed, this::onPollDataFeedRequest);
registerPacketListener(DataFeedMessage.StartDataFeed, this::onStartDataFeed);
registerPacketListener(DataFeedMessage.PollDataFeed, this::onPollDataFeedRequest);
this.api.server.addOnTick(this::sendDataFeedUpdate);
}
private void onDataFeedRequest(GenericConnection conn, InboundPacket inboundPacket) {
DataFeedRequest req = (DataFeedRequest) inboundPacket.packet(new DataFeedRequest());
private void onStartDataFeed(GenericConnection conn, DataFeedMessageHeader header) {
StartDataFeed req = (StartDataFeed) header.message(new StartDataFeed());
if (req == null) return;
int dataFeeds = req.dataFeedsLength();
conn.getContext().getDataFeedConfigList().clear();
for (int i = 0; i < dataFeeds; i++) {
// Using the object api here because we need to copy from the buffer anyway so let's do it from here and send the reference to an arraylist
DataFeedConfigT config = req.dataFeeds(i).unpack();
conn.getContext().getDataFeedConfigList().add(config);
conn.getContext().getDataFeedTimers().add(System.currentTimeMillis());
System.out.println("NEW CONFIG");
}
}
private void onPollDataFeedRequest(GenericConnection conn, InboundPacket inboundPacket) {
private void onPollDataFeedRequest(GenericConnection conn, DataFeedMessageHeader inboundPacket) {
}
public ByteBuffer dataFeedBuffer(DataFeedConfigT config) {
public int dataFeedBuffer(FlatBufferBuilder fbb, DataFeedConfigT config) {
int devicesOffset = DataFeedBuilder.createDevicesData(fbb, config, this.api.server.getTrackersServer().getConnections());
FlatBufferBuilder fbb = new FlatBufferBuilder(300);
DataFeedUpdate.startDataFeedUpdate(fbb);
if (config.getDataMask() != null) {
DeviceStatusMaskT maskT = config.getDataMask();
List<TrackerUDPConnection> devicesList = this.api.server.getTrackersServer().getConnections();
int[] devicesStatusOffsets = new int[devicesList.size()];
for (int i = 0; i < devicesList.size(); i++) {
TrackerUDPConnection device = devicesList.get(i);
FirmwareInfoMaskT firmwareInfoMaskT = maskT.getFirmwareInfo();
int nameOffset = -1;
int versionOffset = -1;
if (maskT.getCustomName())
nameOffset = fbb.createString(device.name);
if (firmwareInfoMaskT != null && firmwareInfoMaskT.getFirmwareVersion())
versionOffset = fbb.createString(device.firmwareBuild + "");
int firmwareInfoOffset = -1;
if (firmwareInfoMaskT != null) {
{
FirmwareInfo.startFirmwareInfo(fbb);
if (firmwareInfoMaskT.getFirmwareVersion())
FirmwareInfo.addFirmwareVersion(fbb, versionOffset);
if (firmwareInfoMaskT.getDisplayName())
firmwareInfoOffset = FirmwareInfo.endFirmwareInfo(fbb);
DeviceStatus.addFirmwareInfo(fbb, firmwareInfoOffset);
}
}
{
DeviceStatus.startDeviceStatus(fbb);
if (maskT.getCustomName())
DeviceStatus.addCustomName(fbb, nameOffset);
if (firmwareInfoMaskT != null)
DeviceStatus.addFirmwareInfo(fbb, firmwareInfoOffset);
devicesStatusOffsets[i] = DeviceStatus.endDeviceStatus(fbb);
}
}
int devices = DataFeedUpdate.createDevicesVector(fbb, devicesStatusOffsets);
DataFeedUpdate.addDevices(fbb, devices);
}
return null;
return DataFeedUpdate.createDataFeedUpdate(fbb, devicesOffset, -1);
}
public void sendDataFeedUpdate() {
long currTime = System.currentTimeMillis();
this.api.getAPIServers().forEach((server) -> {
server.getAPIConnections().values().forEach((conn) -> {
FlatBufferBuilder fbb = null;
int configsCount = conn.getContext().getDataFeedConfigList().size();
// conn.send(this.dataFeedBuffer(conn.getContext().));
int[] data = new int[configsCount];
for (int index = 0; index < configsCount; index++) {
Long lastTimeSent = conn.getContext().getDataFeedTimers().get(index);
DataFeedConfigT configT = conn.getContext().getDataFeedConfigList().get(index);
if (currTime - lastTimeSent > configT.getMinimumTimeSinceLast()) {
if (fbb == null) {
// That way we create a buffer only when needed
fbb = new FlatBufferBuilder(300);
}
int messageOffset = this.dataFeedBuffer(fbb, configT);
DataFeedMessageHeader.startDataFeedMessageHeader(fbb);
DataFeedMessageHeader.addMessage(fbb, messageOffset);
DataFeedMessageHeader.addMessageType(fbb, DataFeedMessage.DataFeedUpdate);
data[index] = DataFeedMessageHeader.endDataFeedMessageHeader(fbb);
conn.getContext().getDataFeedTimers().set(index, currTime);
}
}
if (fbb != null) {
int messages = MessageBundle.createRpcMsgsVector(fbb, data);
int packet = createMessage(fbb, messages, -1);
fbb.finish(packet);
conn.send(fbb.dataBuffer());
}
});
});
}
@Override
public void onMessage(GenericConnection conn, DataFeedMessageHeader message) {
BiConsumer<GenericConnection, DataFeedMessageHeader> consumer = this.handlers[message.messageType()];
if (consumer != null)
consumer.accept(conn, message);
else
LogManager.log.info("[ProtocolAPI] Unhandled Datafeed packet received id: " + message.messageType());
}
@Override
public int messagesCount() {
return DataFeedMessage.names.length;
}
}
@@ -2,27 +2,22 @@ package dev.slimevr.websocketapi;
import com.google.flatbuffers.FlatBufferBuilder;
import dev.slimevr.VRServer;
import io.eiren.util.logging.LogManager;
import slimevr_protocol.InboundPacket;
import slimevr_protocol.InboundUnion;
import slimevr_protocol.OutboundPacket;
import slimevr_protocol.MessageBundle;
import slimevr_protocol.data_feed.DataFeedMessage;
import slimevr_protocol.data_feed.DataFeedMessageHeader;
import slimevr_protocol.rpc.RpcMessageHeader;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiConsumer;
public class ProtocolAPI {
private int outbountPacketCount = 0;
public final VRServer server;
public final RPCHandler rpcHandler;
public final DataFeedHandler dataFeedHandler;
private List<ProtocolAPIServer> servers = new ArrayList<>();
@SuppressWarnings("unchecked")
public final BiConsumer<GenericConnection, InboundPacket>[] inboundHandlers = new BiConsumer[InboundUnion.names.length] ;
private final List<ProtocolAPIServer> servers = new ArrayList<>();
public ProtocolAPI(VRServer server) {
this.server = server;
@@ -31,24 +26,17 @@ public class ProtocolAPI {
}
public void onMessage(GenericConnection conn, ByteBuffer message) {
InboundPacket inboundPacket = InboundPacket.getRootAsInboundPacket(message);
MessageBundle messageBundle = MessageBundle.getRootAsMessageBundle(message);
BiConsumer<GenericConnection, InboundPacket> consumer = this.inboundHandlers[inboundPacket.packetType()];
if (consumer != null)
consumer.accept(conn, inboundPacket);
else
LogManager.log.info("[ProtocolAPI] Unhandled packet received id: " + inboundPacket.packetType());
}
for (int index = 0; index < messageBundle.dataFeedMsgsLength(); index++) {
DataFeedMessageHeader header = messageBundle.dataFeedMsgsVector().get(index);
this.dataFeedHandler.onMessage(conn, header);
}
public void registerPacketListener(byte packetType, BiConsumer<GenericConnection, InboundPacket> consumer) {
if (this.inboundHandlers[packetType] != null)
this.inboundHandlers[packetType] = this.inboundHandlers[packetType].andThen(consumer);
else
this.inboundHandlers[packetType] = consumer;
}
public int createOutboundPacket(FlatBufferBuilder fbb, byte packetType, int packetOffset) {
return OutboundPacket.createOutboundPacket(fbb, this.outbountPacketCount++, false, packetType, packetOffset);
for (int index = 0; index < messageBundle.rpcMsgsLength(); index++) {
RpcMessageHeader header = messageBundle.rpcMsgsVector().get(index);
this.rpcHandler.onMessage(conn, header);
}
}
public List<ProtocolAPIServer> getAPIServers() {
@@ -0,0 +1,34 @@
package dev.slimevr.websocketapi;
import com.google.flatbuffers.FlatBufferBuilder;
import slimevr_protocol.MessageBundle;
import java.util.function.BiConsumer;
public abstract class ProtocolHandler<H> {
public final BiConsumer<GenericConnection, H>[] handlers;
public ProtocolHandler() {
this.handlers = new BiConsumer[this.messagesCount()];
}
public abstract void onMessage(GenericConnection conn, H message);
public abstract int messagesCount();
public void registerPacketListener(byte packetType, BiConsumer<GenericConnection, H> consumer) {
if (this.handlers[packetType] != null)
this.handlers[packetType] = this.handlers[packetType].andThen(consumer);
else
this.handlers[packetType] = consumer;
}
public int createMessage(FlatBufferBuilder fbb, int datafeedMessagesOffset, int rpcMsgsOffset) {
MessageBundle.startMessageBundle(fbb);
if (datafeedMessagesOffset > -1)
MessageBundle.addDataFeedMsgs(fbb, datafeedMessagesOffset);
if (rpcMsgsOffset > -1)
MessageBundle.addRpcMsgs(fbb, rpcMsgsOffset);
return MessageBundle.endMessageBundle(fbb);
}
}
@@ -4,56 +4,58 @@ import com.google.flatbuffers.FlatBufferBuilder;
import dev.slimevr.platform.windows.WindowsNamedPipeBridge;
import dev.slimevr.vr.trackers.*;
import io.eiren.util.logging.LogManager;
import org.java_websocket.WebSocket;
import slimevr_protocol.InboundPacket;
import slimevr_protocol.InboundUnion;
import slimevr_protocol.OutboundUnion;
import slimevr_protocol.MessageBundle;
import slimevr_protocol.datatypes.TransactionId;
import slimevr_protocol.rpc.*;
public class RPCHandler {
import java.util.function.BiConsumer;
public class RPCHandler extends ProtocolHandler<RpcMessageHeader> {
private final ProtocolAPI api;
private long currTransactionId = 0;
public RPCHandler(ProtocolAPI api) {
super();
this.api = api;
api.registerPacketListener(InboundUnion.slimevr_protocol_rpc_ResetRequest, this::onResetRequest);
api.registerPacketListener(InboundUnion.slimevr_protocol_rpc_AssignTrackerRequest, this::onAssignTrackerRequest);
api.registerPacketListener(InboundUnion.slimevr_protocol_rpc_SettingsRequest, this::onSettingsRequest);
api.registerPacketListener(InboundUnion.slimevr_protocol_rpc_ChangeSettingsRequest, this::onChangeSettingsRequest);
registerPacketListener(RpcMessage.ResetRequest, this::onResetRequest);
registerPacketListener(RpcMessage.AssignTrackerRequest, this::onAssignTrackerRequest);
registerPacketListener(RpcMessage.SettingsRequest, this::onSettingsRequest);
registerPacketListener(RpcMessage.ChangeSettingsRequest, this::onChangeSettingsRequest);
}
public void onResetRequest(GenericConnection conn, InboundPacket inboundPacket) {
ResetRequest req = (ResetRequest) inboundPacket.packet(new ResetRequest());
public void onResetRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
ResetRequest req = (ResetRequest) messageHeader.message(new ResetRequest());
if (req == null) return;
if (req.quick()) {
if (req.resetType() == ResetType.Quick)
this.api.server.resetTrackersYaw();
} else {
if (req.resetType() == ResetType.Full)
this.api.server.resetTrackers();
}
LogManager.log.severe("[WebSocketAPI] Reset performed");
}
public void onAssignTrackerRequest(GenericConnection conn, InboundPacket inboundPacket) {
AssignTrackerRequest req = (AssignTrackerRequest) inboundPacket.packet(new AssignTrackerRequest());
public void onAssignTrackerRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
AssignTrackerRequest req = (AssignTrackerRequest) messageHeader.message(new AssignTrackerRequest());
if (req == null) return;
Tracker tracker = this.api.server.getAllTrackers().get(req.id());
Tracker tracker = this.api.server.getAllTrackers().get(req.trackerId().trackerNum());
if (tracker == null)
return ;
tracker.setBodyPosition(TrackerPosition.getById(req.bodyPosition()));
if (tracker instanceof IMUTracker) {
IMUTracker imu = (IMUTracker) tracker;
TrackerMountingRotation rot = TrackerMountingRotation.fromAngle(req.mountingRotation());
if (rot != null)
imu.setMountingRotation(rot);
// TrackerMountingRotation rot = TrackerMountingRotation.fromAngle(req.mountingRotation());
// if (rot != null)
// imu.setMountingRotation(rot);
}
this.api.server.trackerUpdated(tracker);
}
public void onSettingsRequest(GenericConnection conn, InboundPacket inboundPacket) {
public void onSettingsRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
FlatBufferBuilder fbb = new FlatBufferBuilder(32);
WindowsNamedPipeBridge bridge = this.api.server.getVRBridge(WindowsNamedPipeBridge.class);
@@ -74,14 +76,14 @@ public class RPCHandler {
);
int settings = SettingsResponse.createSettingsResponse(fbb, steamvrTrackerSettings, filterSettings);
int outbound = this.api.createOutboundPacket(fbb, OutboundUnion.slimevr_protocol_rpc_SettingsResponse, settings);
int outbound = createRPCMessage(fbb, RpcMessage.SettingsResponse, settings);
fbb.finish(outbound);
conn.send(fbb.dataBuffer());
}
public void onChangeSettingsRequest(GenericConnection conn, InboundPacket inboundPacket) {
public void onChangeSettingsRequest(GenericConnection conn, RpcMessageHeader messageHeader) {
ChangeSettingsRequest req = (ChangeSettingsRequest) inboundPacket.packet(new ChangeSettingsRequest());
ChangeSettingsRequest req = (ChangeSettingsRequest) messageHeader.message(new ChangeSettingsRequest());
if (req == null) return;
if (req.steamVrTrackers() != null) {
@@ -103,4 +105,34 @@ public class RPCHandler {
}
}
}
@Override
public void onMessage(GenericConnection conn, RpcMessageHeader message) {
BiConsumer<GenericConnection, RpcMessageHeader> consumer = this.handlers[message.messageType()];
if (consumer != null)
consumer.accept(conn, message);
else
LogManager.log.info("[ProtocolAPI] Unhandled RPC packet received id: " + message.messageType());
}
public int createRPCMessage(FlatBufferBuilder fbb, byte messageType, int messageOffset) {
int [] data = new int[1];
int txId = TransactionId.createTransactionId(fbb, currTransactionId++);
RpcMessageHeader.startRpcMessageHeader(fbb);
RpcMessageHeader.addMessage(fbb, messageOffset);
RpcMessageHeader.addMessageType(fbb, messageType);
RpcMessageHeader.addTxId(fbb, txId);
data[0] = RpcMessageHeader.endRpcMessageHeader(fbb);
int messages = MessageBundle.createRpcMsgsVector(fbb, data);
return createMessage(fbb, -1, messages);
}
@Override
public int messagesCount() {
return RpcMessage.names.length;
}
}
@@ -271,15 +271,7 @@ public class WebsocketAPI extends WebSocketServer implements SerialListener {
public void onChangeSettingsRequest(WebSocket conn, ChangeSettingsRequest req) {
if (req.steamVrTrackers() != null) {
WindowsNamedPipeBridge bridge = this.server.getVRBridge(WindowsNamedPipeBridge.class);
bridge.changeShareSettings(TrackerRole.WAIST, req.steamVrTrackers().waist());
bridge.changeShareSettings(TrackerRole.CHEST, req.steamVrTrackers().chest());
bridge.changeShareSettings(TrackerRole.LEFT_FOOT, req.steamVrTrackers().legs());
bridge.changeShareSettings(TrackerRole.RIGHT_FOOT, req.steamVrTrackers().legs());
bridge.changeShareSettings(TrackerRole.LEFT_KNEE, req.steamVrTrackers().knees());
bridge.changeShareSettings(TrackerRole.RIGHT_KNEE, req.steamVrTrackers().knees());
bridge.changeShareSettings(TrackerRole.LEFT_ELBOW, req.steamVrTrackers().elbows());
bridge.changeShareSettings(TrackerRole.RIGHT_ELBOW, req.steamVrTrackers().elbows());
W;lp.
}
if (req.filtering() != null) {