package dev.slimevr; import java.io.File; import java.io.FileInputStream; import java.io.FileNotFoundException; import java.io.FileOutputStream; import java.io.IOException; import java.net.InetAddress; import java.net.UnknownHostException; import java.util.HashMap; import java.util.Iterator; import java.util.List; import java.util.Map; import java.util.Queue; import java.util.concurrent.LinkedBlockingQueue; import java.util.function.Consumer; import dev.slimevr.bridge.Bridge; import dev.slimevr.platform.windows.WindowsNamedPipeBridge; import dev.slimevr.bridge.VMCBridge; import dev.slimevr.poserecorder.BVHRecorder; import dev.slimevr.serial.SerialHandler; import dev.slimevr.protocol.ProtocolAPI; import dev.slimevr.vr.trackers.*; import dev.slimevr.websocketapi.WebSocketVRBridge; import dev.slimevr.util.ann.VRServerThread; import dev.slimevr.vr.processor.HumanPoseProcessor; import dev.slimevr.vr.processor.skeleton.HumanSkeleton; import dev.slimevr.vr.trackers.udp.TrackersUDPServer; import io.eiren.util.OperatingSystem; import io.eiren.util.ann.ThreadSafe; import io.eiren.util.ann.ThreadSecure; import io.eiren.util.collections.FastList; import io.eiren.yaml.YamlException; import io.eiren.yaml.YamlFile; import io.eiren.yaml.YamlNode; import slimevr_protocol.datatypes.TrackerIdT; public class VRServer extends Thread { private final List trackers = new FastList<>(); public final HumanPoseProcessor humanPoseProcessor; private final TrackersUDPServer trackersServer; private final List bridges = new FastList<>(); private final Queue tasks = new LinkedBlockingQueue<>(); private final Map configuration = new HashMap<>(); public final YamlFile config = new YamlFile(); public final HMDTracker hmdTracker; private final List> newTrackersConsumers = new FastList<>(); private final List onTick = new FastList<>(); private final List shareTrackers; private final BVHRecorder bvhRecorder; private final SerialHandler serialHandler; private final ProtocolAPI protocolAPI; public VRServer() { super("VRServer"); loadConfig(); serialHandler = new SerialHandler(); protocolAPI = new ProtocolAPI(this); hmdTracker = new HMDTracker("HMD"); hmdTracker.position.set(0, 1.8f, 0); // Set starting position for easier debugging // TODO Multiple processors humanPoseProcessor = new HumanPoseProcessor(this, hmdTracker); shareTrackers = humanPoseProcessor.getComputedTrackers(); // Start server for SlimeVR trackers trackersServer = new TrackersUDPServer(6969, "Sensors UDP server", this::registerTracker); // OpenVR bridge currently only supports Windows if(OperatingSystem.getCurrentPlatform() == OperatingSystem.WINDOWS) { // Create named pipe bridge for SteamVR driver WindowsNamedPipeBridge driverBridge = new WindowsNamedPipeBridge(hmdTracker, "steamvr", "SteamVR Driver Bridge", "\\\\.\\pipe\\SlimeVRDriver", shareTrackers); tasks.add(() -> driverBridge.startBridge()); bridges.add(driverBridge); // Create named pipe bridge for SteamVR input // TODO: how do we want to handle HMD input from the feeder app? WindowsNamedPipeBridge feederBridge = new WindowsNamedPipeBridge(null, "steamvr_feeder", "SteamVR Feeder Bridge", "\\\\.\\pipe\\SlimeVRInput", new FastList()); tasks.add(() -> feederBridge.startBridge()); bridges.add(feederBridge); } // Create WebSocket server WebSocketVRBridge wsBridge = new WebSocketVRBridge(hmdTracker, shareTrackers, this); tasks.add(() -> wsBridge.startBridge()); bridges.add(wsBridge); // Create VMCBridge try { VMCBridge vmcBridge = new VMCBridge(39539, 39540, InetAddress.getLocalHost()); tasks.add(() -> vmcBridge.startBridge()); bridges.add(vmcBridge); } catch(UnknownHostException e) { e.printStackTrace(); } bvhRecorder = new BVHRecorder(this); registerTracker(hmdTracker); for(int i = 0; i < shareTrackers.size(); ++i) registerTracker(shareTrackers.get(i)); } public boolean hasBridge(Class bridgeClass) { for(int i = 0; i < bridges.size(); ++i) { if(bridgeClass.isAssignableFrom(bridges.get(i).getClass())) return true; } return false; } @ThreadSafe public E getVRBridge(Class bridgeClass) { for(int i = 0; i < bridges.size(); ++i) { Bridge b = bridges.get(i); if(bridgeClass.isAssignableFrom(b.getClass())) return bridgeClass.cast(b); } return null; } @ThreadSafe public TrackerConfig getTrackerConfig(Tracker tracker) { synchronized(configuration) { TrackerConfig config = configuration.get(tracker.getName()); if(config == null) { config = new TrackerConfig(tracker); configuration.put(tracker.getName(), config); } return config; } } private void loadConfig() { try { config.load(new FileInputStream(new File("vrconfig.yml"))); } catch(FileNotFoundException e) { // Config file didn't exist, is not an error } catch(YamlException e) { e.printStackTrace(); } List trackersConfig = config.getNodeList("trackers", null); for(int i = 0; i < trackersConfig.size(); ++i) { TrackerConfig cfg = new TrackerConfig(trackersConfig.get(i)); synchronized(configuration) { configuration.put(cfg.trackerName, cfg); } } } public void addOnTick(Runnable runnable) { this.onTick.add(runnable); } @ThreadSafe public void addNewTrackerConsumer(Consumer consumer) { queueTask(() -> { newTrackersConsumers.add(consumer); for(int i = 0; i < trackers.size(); ++i) consumer.accept(trackers.get(i)); }); } @ThreadSafe public void trackerUpdated(Tracker tracker) { queueTask(() -> { humanPoseProcessor.trackerUpdated(tracker); TrackerConfig tc = getTrackerConfig(tracker); tracker.saveConfig(tc); saveConfig(); }); } @ThreadSafe public void addSkeletonUpdatedCallback(Consumer consumer) { queueTask(() -> { humanPoseProcessor.addSkeletonUpdatedCallback(consumer); }); } @ThreadSafe public synchronized void saveConfig() { List nodes = config.getNodeList("trackers", null); List> trackersConfig = new FastList<>(nodes.size()); for(int i = 0; i < nodes.size(); ++i) { trackersConfig.add(nodes.get(i).root); } config.setProperty("trackers", trackersConfig); synchronized(configuration) { Iterator iterator = configuration.values().iterator(); while(iterator.hasNext()) { TrackerConfig tc = iterator.next(); Map cfg = null; for(int i = 0; i < trackersConfig.size(); ++i) { Map c = trackersConfig.get(i); if(tc.trackerName.equals(c.get("name"))) { cfg = c; break; } } if(cfg == null) { cfg = new HashMap<>(); trackersConfig.add(cfg); } tc.saveConfig(new YamlNode(cfg)); } } File cfgFile = new File("vrconfig.yml"); try { config.save(new FileOutputStream(cfgFile)); } catch(IOException e) { e.printStackTrace(); } } @Override @VRServerThread public void run() { trackersServer.start(); while(true) { // final long start = System.currentTimeMillis(); do { Runnable task = tasks.poll(); if(task == null) break; task.run(); } while(true); for(int i = 0; i < onTick.size(); ++i) { this.onTick.get(i).run(); } for(int i = 0; i < bridges.size(); ++i) bridges.get(i).dataRead(); for(int i = 0; i < trackers.size(); ++i) trackers.get(i).tick(); humanPoseProcessor.update(); for(int i = 0; i < bridges.size(); ++i) bridges.get(i).dataWrite(); // final long time = System.currentTimeMillis() - start; try { Thread.sleep(1); // 1000Hz } catch(InterruptedException e) { } } } @ThreadSafe public void queueTask(Runnable r) { tasks.add(r); } @VRServerThread private void trackerAdded(Tracker tracker) { humanPoseProcessor.trackerAdded(tracker); } @ThreadSecure public void registerTracker(Tracker tracker) { TrackerConfig config = getTrackerConfig(tracker); tracker.loadConfig(config); queueTask(() -> { trackers.add(tracker); trackerAdded(tracker); for(int i = 0; i < newTrackersConsumers.size(); ++i) newTrackersConsumers.get(i).accept(tracker); }); } public void updateTrackersFilters(TrackerFilters filter, float amount, int ticks) { config.setProperty("filters.type", filter.name()); config.setProperty("filters.amount", amount); config.setProperty("filters.tickCount", ticks); saveConfig(); IMUTracker imu; for (Tracker t : this.getAllTrackers()) { Tracker realTracker = t; if(t instanceof ReferenceAdjustedTracker) realTracker = ((ReferenceAdjustedTracker) t).getTracker(); if(realTracker instanceof IMUTracker){ imu = (IMUTracker)realTracker; imu.setFilter(filter.name(), amount, ticks); } } } public void resetTrackers() { queueTask(() -> { humanPoseProcessor.resetTrackers(); }); } public void resetTrackersYaw() { queueTask(() -> { humanPoseProcessor.resetTrackersYaw(); }); } public int getTrackersCount() { return trackers.size(); } public List getAllTrackers() { return new FastList<>(trackers); } public Tracker getTrackerById(TrackerIdT id) { for (Tracker tracker : trackers) { if (tracker.getTrackerNum() != id.getTrackerNum()) continue; if (tracker.getDevice() == null && id.getDeviceId() != null) continue; if (tracker.getDevice() != null && id.getDeviceId() == null) continue; if (tracker.getDevice().getId() != id.getDeviceId().getId()) continue; return tracker; } return null; } public BVHRecorder getBvhRecorder() { return this.bvhRecorder; } public SerialHandler getSerialHandler() { return this.serialHandler; } public ProtocolAPI getProtocolAPI() { return protocolAPI; } public TrackersUDPServer getTrackersServer() { return trackersServer; } }