Support IVRServerDriverHost_006

Been running Rift CV1 with Steamvr 2.0 basestations for a while and did not run into any problems so far even when purely on Index. The lighthouse driver station poses update on their (re)initialisation or some speciffic(dynamic recalibration?) cases and not immediately.

LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2018 Justin Li
+Copyright (c) 2020 Justin Li
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

OpenVR-SpaceCalibrator/Calibration.cpp

@@ -113,7 +113,7 @@ Eigen::Vector3d CalibrateRotation(const std::vector<Sample> &samples)
 	}
 	char buf[256];
 	snprintf(buf, sizeof buf, "Got %zd samples with %zd delta samples\n", samples.size(), deltas.size());
-	CalCtx.Message(buf);
+	CalCtx.Log(buf);
 
 	// Kabsch algorithm
 
@@ -155,7 +155,7 @@ Eigen::Vector3d CalibrateRotation(const std::vector<Sample> &samples)
 	Eigen::Vector3d euler = rot.eulerAngles(2, 1, 0) * 180.0 / EIGEN_PI;
 
 	snprintf(buf, sizeof buf, "Calibrated rotation: yaw=%.2f pitch=%.2f roll=%.2f\n", euler[1], euler[2], euler[0]);
-	CalCtx.Message(buf);
+	CalCtx.Log(buf);
 	return euler;
 }
 
@@ -198,7 +198,7 @@ Eigen::Vector3d CalibrateTranslation(const std::vector<Sample> &samples)
 
 	char buf[256];
 	snprintf(buf, sizeof buf, "Calibrated translation x=%.2f y=%.2f z=%.2f\n", transcm[0], transcm[1], transcm[2]);
-	CalCtx.Message(buf);
+	CalCtx.Log(buf);
 	return transcm;
 }
 
@@ -214,15 +214,15 @@ Sample CollectSample(const CalibrationContext &ctx)
 	bool ok = true;
 	if (!reference.bPoseIsValid)
 	{
-		CalCtx.Message("Reference device is not tracking\n"); ok = false;
+		CalCtx.Log("Reference device is not tracking\n"); ok = false;
 	}
 	if (!target.bPoseIsValid)
 	{
-		CalCtx.Message("Target device is not tracking\n"); ok = false;
+		CalCtx.Log("Target device is not tracking\n"); ok = false;
 	}
 	if (!ok)
 	{
-		CalCtx.Message("Aborting calibration!\n");
+		CalCtx.Log("Aborting calibration!\n");
 		CalCtx.state = CalibrationState::None;
 		return Sample();
 	}
@@ -273,9 +273,12 @@ void ResetAndDisableOffsets(uint32_t id)
 	Driver.SendBlocking(req);
 }
 
+static_assert(vr::k_unTrackedDeviceIndex_Hmd == 0, "HMD index expected to be 0");
+
 void ScanAndApplyProfile(CalibrationContext &ctx)
 {
 	char buffer[vr::k_unMaxPropertyStringSize];
+	ctx.enabled = ctx.validProfile;
 
 	for (uint32_t id = 0; id < vr::k_unMaxTrackedDeviceCount; ++id)
 	{
@@ -292,20 +295,12 @@ void ScanAndApplyProfile(CalibrationContext &ctx)
 			continue;
 		}*/
 
-		if (!ctx.validProfile)
+		if (!ctx.enabled)
 		{
 			ResetAndDisableOffsets(id);
 			continue;
 		}
 
-		if (deviceClass == vr::TrackedDeviceClass_TrackingReference || deviceClass == vr::TrackedDeviceClass_HMD)
-		{
-			//auto p = ctx.devicePoses[id].mDeviceToAbsoluteTracking.m;
-			//printf("REF %d: %f %f %f\n", id, p[0][3], p[1][3], p[2][3]);
-			ResetAndDisableOffsets(id);
-			continue;
-		}
-
 		vr::ETrackedPropertyError err = vr::TrackedProp_Success;
 		vr::VRSystem()->GetStringTrackedDeviceProperty(id, vr::Prop_TrackingSystemName_String, buffer, vr::k_unMaxPropertyStringSize, &err);
 
@@ -317,6 +312,21 @@ void ScanAndApplyProfile(CalibrationContext &ctx)
 
 		std::string trackingSystem(buffer);
 
+		if (id == vr::k_unTrackedDeviceIndex_Hmd)
+		{
+			//auto p = ctx.devicePoses[id].mDeviceToAbsoluteTracking.m;
+			//printf("HMD %d: %f %f %f\n", id, p[0][3], p[1][3], p[2][3]);
+
+			if (trackingSystem != ctx.referenceTrackingSystem)
+			{
+				// Currently using an HMD with a different tracking system than the calibration.
+				ctx.enabled = false;
+			}
+
+			ResetAndDisableOffsets(id);
+			continue;
+		}
+
 		if (trackingSystem != ctx.targetTrackingSystem)
 		{
 			ResetAndDisableOffsets(id);
@@ -333,7 +343,7 @@ void ScanAndApplyProfile(CalibrationContext &ctx)
 		Driver.SendBlocking(req);
 	}
 
-	if (ctx.chaperone.valid && ctx.chaperone.autoApply)
+	if (ctx.enabled && ctx.chaperone.valid && ctx.chaperone.autoApply)
 	{
 		uint32_t quadCount = 0;
 		vr::VRChaperoneSetup()->GetLiveCollisionBoundsInfo(nullptr, &quadCount);
@@ -351,7 +361,7 @@ void StartCalibration()
 {
 	CalCtx.state = CalibrationState::Begin;
 	CalCtx.wantedUpdateInterval = 0.0;
-	CalCtx.messages = "";
+	CalCtx.messages.clear();
 }
 
 void CalibrationTick(double time)
@@ -396,26 +406,26 @@ void CalibrationTick(double time)
 
 		if (ctx.referenceID == -1)
 		{
-			CalCtx.Message("Missing reference device\n"); ok = false;
+			CalCtx.Log("Missing reference device\n"); ok = false;
 		}
 		else if (!ctx.devicePoses[ctx.referenceID].bPoseIsValid)
 		{
-			CalCtx.Message("Reference device is not tracking\n"); ok = false;
+			CalCtx.Log("Reference device is not tracking\n"); ok = false;
 		}
 
 		if (ctx.targetID == -1)
 		{
-			CalCtx.Message("Missing target device\n"); ok = false;
+			CalCtx.Log("Missing target device\n"); ok = false;
 		}
 		else if (!ctx.devicePoses[ctx.targetID].bPoseIsValid)
 		{
-			CalCtx.Message("Target device is not tracking\n"); ok = false;
+			CalCtx.Log("Target device is not tracking\n"); ok = false;
 		}
 
 		if (!ok)
 		{
 			ctx.state = CalibrationState::None;
-			CalCtx.Message("Aborting calibration!\n");
+			CalCtx.Log("Aborting calibration!\n");
 			return;
 		}
 
@@ -425,7 +435,7 @@ void CalibrationTick(double time)
 
 		char buf[256];
 		snprintf(buf, sizeof buf, "Starting calibration, referenceID=%d targetID=%d\n", ctx.referenceID, ctx.targetID);
-		CalCtx.Message(buf);
+		CalCtx.Log(buf);
 		return;
 	}
 
@@ -434,15 +444,15 @@ void CalibrationTick(double time)
 	{
 		return;
 	}
-	CalCtx.Message(".");
 
-	const int totalSamples = 100;
 	static std::vector<Sample> samples;
 	samples.push_back(sample);
 
-	if (samples.size() == totalSamples)
+	CalCtx.Progress(samples.size(), CalCtx.SampleCount());
+
+	if (samples.size() == CalCtx.SampleCount())
 	{
-		CalCtx.Message("\n");
+		CalCtx.Log("\n");
 		if (ctx.state == CalibrationState::Rotation)
 		{
 			ctx.calibratedRotation = CalibrateRotation(samples);
@@ -465,8 +475,9 @@ void CalibrationTick(double time)
 			req.setDeviceTransform = { ctx.targetID, true, vrTrans };
 			Driver.SendBlocking(req);
 
+			ctx.validProfile = true;
 			SaveProfile(ctx);
-			CalCtx.Message("Finished calibration, profile saved\n");
+			CalCtx.Log("Finished calibration, profile saved\n");
 
 			ctx.state = CalibrationState::None;
 		}

OpenVR-SpaceCalibrator/Calibration.h

@@ -24,10 +24,19 @@ struct CalibrationContext
 	std::string referenceTrackingSystem;
 	std::string targetTrackingSystem;
 
+	bool enabled = false;
 	bool validProfile = false;
 	double timeLastTick = 0, timeLastScan = 0;
 	double wantedUpdateInterval = 1.0;
 
+	enum Speed
+	{
+		FAST = 0,
+		SLOW = 1,
+		VERY_SLOW = 2
+	};
+	Speed calibrationSpeed = FAST;
+
 	vr::TrackedDevicePose_t devicePoses[vr::k_unMaxTrackedDeviceCount];
 
 	struct Chaperone
@@ -39,13 +48,68 @@ struct CalibrationContext
 		vr::HmdVector2_t playSpaceSize;
 	} chaperone;
 
-	std::string messages;
-
-	void Message(const std::string &msg)
+	void Clear()
 	{
-		messages += msg;
+		chaperone.geometry.clear();
+		chaperone.standingCenter = vr::HmdMatrix34_t();
+		chaperone.playSpaceSize = vr::HmdVector2_t();
+		chaperone.valid = false;
+
+		calibratedRotation = Eigen::Vector3d();
+		calibratedTranslation = Eigen::Vector3d();
+		referenceTrackingSystem = "";
+		targetTrackingSystem = "";
+		enabled = false;
+		validProfile = false;
+	}
+
+	size_t SampleCount()
+	{
+		switch (calibrationSpeed)
+		{
+		case FAST:
+			return 100;
+		case SLOW:
+			return 250;
+		case VERY_SLOW:
+			return 500;
+		}
+		return 100;
+	}
+
+	struct Message
+	{
+		enum Type
+		{
+			String,
+			Progress
+		} type = String;
+
+		Message(Type type) : type(type) { }
+
+		std::string str;
+		int progress, target;
+	};
+
+	std::vector<Message> messages;
+
+	void Log(const std::string &msg)
+	{
+		if (messages.empty() || messages.back().type == Message::Progress)
+			messages.push_back(Message(Message::String));
+
+		messages.back().str += msg;
 		std::cerr << msg;
 	}
+
+	void Progress(int current, int target)
+	{
+		if (messages.empty() || messages.back().type == Message::String)
+			messages.push_back(Message(Message::Progress));
+
+		messages.back().progress = current;
+		messages.back().target = target;
+	}
 };
 
 extern CalibrationContext CalCtx;

OpenVR-SpaceCalibrator/Configuration.cpp

@@ -9,16 +9,7 @@
 #include <iomanip>
 #include <limits>
 
-static void UpgradeProfileV1(CalibrationContext &ctx);
-static void ParseProfileV2(CalibrationContext &ctx, std::istream &stream);
-
-static std::string ConfigFileName()
-{
-	std::string vrRuntimeConfigName = vr::VR_RuntimePath();
-	return vrRuntimeConfigName + "\\..\\..\\..\\config\\01spacecalibrator\\calibration.json";
-}
-
-picojson::array FloatArray(const float *buf, int numFloats)
+static picojson::array FloatArray(const float *buf, int numFloats)
 {
 	picojson::array arr;
 
@@ -28,7 +19,7 @@ picojson::array FloatArray(const float *buf, int numFloats)
 	return arr;
 }
 
-void LoadFloatArray(const picojson::value &obj, float *buf, int numFloats)
+static void LoadFloatArray(const picojson::value &obj, float *buf, int numFloats)
 {
 	if (!obj.is<picojson::array>())
 		throw std::runtime_error("expected array, got " + obj.to_str());
@@ -41,38 +32,7 @@ void LoadFloatArray(const picojson::value &obj, float *buf, int numFloats)
 		buf[i] = (float) arr[i].get<double>();
 }
 
-void LoadProfile(CalibrationContext &ctx)
-{
-	ctx.validProfile = false;
-
-	std::ifstream file(ConfigFileName());
-	if (!file.good())
-	{
-		std::cout << "Profile missing, trying fallback path" << std::endl;
-		// Fallback to working directory, which was the default for a long time.
-		file = std::ifstream("openvr_space_calibration.json");
-	}
-
-
-	if (!file.good())
-	{
-		std::cout << "Fallback profile missing, trying V1 path" << std::endl;
-		UpgradeProfileV1(ctx);
-		return;
-	}
-
-	try
-	{
-		ParseProfileV2(ctx, file);
-		std::cout << "Loaded profile" << std::endl;
-	}
-	catch (const std::runtime_error &e)
-	{
-		std::cerr << "Error loading profile: " << e.what() << std::endl;
-	}
-}
-
-static void ParseProfileV2(CalibrationContext &ctx, std::istream &stream)
+static void ParseProfile(CalibrationContext &ctx, std::istream &stream)
 {
 	picojson::value v;
 	std::string err = picojson::parse(v, stream);
@@ -94,6 +54,9 @@ static void ParseProfileV2(CalibrationContext &ctx, std::istream &stream)
 	ctx.calibratedTranslation(1) = obj["y"].get<double>();
 	ctx.calibratedTranslation(2) = obj["z"].get<double>();
 
+	if (obj["calibration_speed"].is<double>())
+		ctx.calibrationSpeed = (CalibrationContext::Speed)(int) obj["calibration_speed"].get<double>();
+
 	if (obj["chaperone"].is<picojson::object>())
 	{
 		auto chaperone = obj["chaperone"].get<picojson::object>();
@@ -104,7 +67,7 @@ static void ParseProfileV2(CalibrationContext &ctx, std::istream &stream)
 		LoadFloatArray(
 			chaperone["standing_center"],
 			(float *) ctx.chaperone.standingCenter.m,
-			sizeof(ctx.chaperone.standingCenter) / sizeof(float)
+			sizeof(ctx.chaperone.standingCenter.m) / sizeof(float)
 		);
 
 		if (!chaperone["geometry"].is<picojson::array>())
@@ -124,11 +87,10 @@ static void ParseProfileV2(CalibrationContext &ctx, std::istream &stream)
 	ctx.validProfile = true;
 }
 
-void SaveProfile(CalibrationContext &ctx)
+static void WriteProfile(CalibrationContext &ctx, std::ostream &out)
 {
-	std::cout << "Saving profile to " << ConfigFileName() << std::endl;
-
-	std::ofstream file(ConfigFileName());
+	if (!ctx.validProfile)
+		return;
 
 	picojson::object profile;
 	profile["reference_tracking_system"].set<std::string>(ctx.referenceTrackingSystem);
@@ -140,19 +102,22 @@ void SaveProfile(CalibrationContext &ctx)
 	profile["y"].set<double>(ctx.calibratedTranslation(1));
 	profile["z"].set<double>(ctx.calibratedTranslation(2));
 
+	double speed = (int) ctx.calibrationSpeed;
+	profile["calibration_speed"].set<double>(speed);
+
 	if (ctx.chaperone.valid)
 	{
 		picojson::object chaperone;
 		chaperone["auto_apply"].set<bool>(ctx.chaperone.autoApply);
 		chaperone["play_space_size"].set<picojson::array>(FloatArray(ctx.chaperone.playSpaceSize.v, 2));
 
-		chaperone["standing_center"].set<picojson::array>(
-			FloatArray((float *) ctx.chaperone.standingCenter.m,
-			sizeof(ctx.chaperone.standingCenter) / sizeof(float)
+		chaperone["standing_center"].set<picojson::array>(FloatArray(
+			(float *) ctx.chaperone.standingCenter.m,
+			sizeof(ctx.chaperone.standingCenter.m) / sizeof(float)
 		));
 
-		chaperone["geometry"].set<picojson::array>(
-			FloatArray((float *) ctx.chaperone.geometry.data(),
+		chaperone["geometry"].set<picojson::array>(FloatArray(
+			(float *) ctx.chaperone.geometry.data(),
 			sizeof(ctx.chaperone.geometry[0]) / sizeof(float) * ctx.chaperone.geometry.size()
 		));
 
@@ -168,70 +133,89 @@ void SaveProfile(CalibrationContext &ctx)
 	picojson::value profilesV;
 	profilesV.set<picojson::array>(profiles);
 
-	file << profilesV.serialize(true);
-
-	ctx.validProfile = true;
+	out << profilesV.serialize(true);
 }
 
-static void UpgradeProfileV1(CalibrationContext &ctx)
+static void LogRegistryResult(LSTATUS result)
+{
+	char *message;
+	FormatMessageA(FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_ALLOCATE_BUFFER, 0, result, LANG_USER_DEFAULT, (LPSTR)&message, 0, NULL);
+	std::cerr << "Opening registry key: " << message << std::endl;
+}
+
+static const char *RegistryKey = "Software\\OpenVR-SpaceCalibrator";
+
+static std::string ReadRegistryKey()
+{
+	DWORD size = 0;
+	auto result = RegGetValueA(HKEY_CURRENT_USER_LOCAL_SETTINGS, RegistryKey, "Config", RRF_RT_REG_SZ, 0, 0, &size);
+	if (result != ERROR_SUCCESS)
+	{
+		LogRegistryResult(result);
+		return "";
+	}
+
+	std::string str;
+	str.resize(size);
+
+	result = RegGetValueA(HKEY_CURRENT_USER_LOCAL_SETTINGS, RegistryKey, "Config", RRF_RT_REG_SZ, 0, &str[0], &size);
+	if (result != ERROR_SUCCESS)
+	{
+		LogRegistryResult(result);
+		return "";
+	}
+	
+	str.resize(size - 1);
+	return str;
+}
+
+static void WriteRegistryKey(std::string str)
+{
+	HKEY hkey;
+	auto result = RegCreateKeyExA(HKEY_CURRENT_USER_LOCAL_SETTINGS, RegistryKey, 0, REG_NONE, 0, KEY_ALL_ACCESS, 0, &hkey, 0);
+	if (result != ERROR_SUCCESS)
+	{
+		LogRegistryResult(result);
+		return;
+	}
+
+	DWORD size = str.size() + 1;
+
+	result = RegSetValueExA(hkey, "Config", 0, REG_SZ, reinterpret_cast<const BYTE*>(str.c_str()), size);
+	if (result != ERROR_SUCCESS)
+		LogRegistryResult(result);
+
+	RegCloseKey(hkey);
+}
+
+void LoadProfile(CalibrationContext &ctx)
 {
-	std::ifstream file("openvr_space_calibration.txt");
 	ctx.validProfile = false;
 
-	if (!file.good())
+	auto str = ReadRegistryKey();
+	if (str == "")
+	{
+		std::cout << "Profile is empty" << std::endl;
 		return;
+	}
 
-	file
-		>> ctx.targetTrackingSystem
-		>> ctx.calibratedRotation(1) // yaw
-		>> ctx.calibratedRotation(2) // pitch
-		>> ctx.calibratedRotation(0) // roll
-		>> ctx.calibratedTranslation(0) // x
-		>> ctx.calibratedTranslation(1) // y
-		>> ctx.calibratedTranslation(2); // z
-
-	ctx.validProfile = true;
-
-	SaveProfile(ctx);
-
-	file.close();
-	std::remove("openvr_space_calibration.txt");
+	try
+	{
+		std::stringstream io(str);
+		ParseProfile(ctx, io);
+		std::cout << "Loaded profile" << std::endl;
+	}
+	catch (const std::runtime_error &e)
+	{
+		std::cerr << "Error loading profile: " << e.what() << std::endl;
+	}
 }
 
-void WriteActivateMultipleDriversToConfig()
+void SaveProfile(CalibrationContext &ctx)
 {
-	std::string configPath = vr::VR_RuntimePath();
-	configPath += "\\..\\..\\..\\config\\steamvr.vrsettings";
+	std::cout << "Saving profile to registry" << std::endl;
 
-	std::ifstream ifile(configPath);
-	if (!ifile.good())
-		throw std::runtime_error("failed to read steamvr.vrsettings");
-
-	picojson::value v;
-	std::string err = picojson::parse(v, ifile);
-	if (!err.empty())
-		throw std::runtime_error(err);
-
-	ifile.close();
-
-	if (!v.is<picojson::object>())
-		throw std::runtime_error("steamvr.vrsettings is empty");
-
-	auto &root = v.get<picojson::object>();
-
-	if (!root["steamvr"].is<picojson::object>())
-		throw std::runtime_error("steamvr.vrsettings is missing \"steamvr\" key");
-
-	auto &steamvr = root["steamvr"].get<picojson::object>();
-
-	const bool tru = true; // MSVC picks the wrong specialization when passing a literal...
-	steamvr["activateMultipleDrivers"].set<bool>(tru);
-
-	std::ofstream ofile(configPath);
-	if (!ofile.good())
-		throw std::runtime_error("failed to write steamvr.vrsettings");
-
-	v.serialize(std::ostream_iterator<char>(ofile), true);
-
-	std::cout << "Successfully set activateMultipleDrivers to true" << std::endl;
+	std::stringstream io;
+	WriteProfile(ctx, io);
+	WriteRegistryKey(io.str());
 }

OpenVR-SpaceCalibrator/Configuration.h

@@ -4,4 +4,3 @@
 
 void LoadProfile(CalibrationContext &ctx);
 void SaveProfile(CalibrationContext &ctx);
-void WriteActivateMultipleDriversToConfig();

OpenVR-SpaceCalibrator/OpenVR-SpaceCalibrator.cpp

@@ -119,13 +119,45 @@ void TryCreateVROverlay()
 
 	vr::VROverlay()->SetOverlayWidthInMeters(overlayMainHandle, 3.0f);
 	vr::VROverlay()->SetOverlayInputMethod(overlayMainHandle, vr::VROverlayInputMethod_Mouse);
-	vr::VROverlay()->SetOverlayFlag(overlayMainHandle, vr::VROverlayFlags_SendVRScrollEvents, true);
+	vr::VROverlay()->SetOverlayFlag(overlayMainHandle, vr::VROverlayFlags_SendVRDiscreteScrollEvents, true);
 
 	std::string iconPath = cwd;
 	iconPath += "\\icon.png";
 	vr::VROverlay()->SetOverlayFromFile(overlayThumbnailHandle, iconPath.c_str());
 }
 
+void ActivateMultipleDrivers()
+{
+	vr::EVRSettingsError vrSettingsError;
+	bool enabled = vr::VRSettings()->GetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ActivateMultipleDrivers_Bool, &vrSettingsError);
+
+	if (vrSettingsError != vr::VRSettingsError_None)
+	{
+		std::string err = "Could not read \"" + std::string(vr::k_pch_SteamVR_ActivateMultipleDrivers_Bool) + "\" setting: "
+			+ vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+
+		throw std::runtime_error(err);
+	}
+
+	if (!enabled)
+	{
+		vr::VRSettings()->SetBool(vr::k_pch_SteamVR_Section, vr::k_pch_SteamVR_ActivateMultipleDrivers_Bool, true, &vrSettingsError);
+		if (vrSettingsError != vr::VRSettingsError_None)
+		{
+			std::string err = "Could not set \"" + std::string(vr::k_pch_SteamVR_ActivateMultipleDrivers_Bool) + "\" setting: "
+				+ vr::VRSettings()->GetSettingsErrorNameFromEnum(vrSettingsError);
+
+			throw std::runtime_error(err);
+		}
+
+		std::cerr << "Enabled \"" << vr::k_pch_SteamVR_ActivateMultipleDrivers_Bool << "\" setting" << std::endl;
+	}
+	else
+	{
+		std::cerr << "\"" << vr::k_pch_SteamVR_ActivateMultipleDrivers_Bool << "\" setting previously enabled" << std::endl;
+	}
+}
+
 void InitVR()
 {
 	auto initError = vr::VRInitError_None;
@@ -148,6 +180,8 @@ void InitVR()
 	{
 		throw std::runtime_error("OpenVR error: Outdated IVROverlay_Version");
 	}
+
+	ActivateMultipleDrivers();
 }
 
 void RunLoop()
@@ -192,10 +226,11 @@ void RunLoop()
 				char buf[0x400];
 				ImGui::GetActiveText(buf, sizeof buf);
 				buf[0x3ff] = 0;
+				uint32_t unFlags = 0; // EKeyboardFlags 
 
 				vr::VROverlay()->ShowKeyboardForOverlay(
 					overlayMainHandle, vr::k_EGamepadTextInputModeNormal, vr::k_EGamepadTextInputLineModeSingleLine,
-					"Space Calibrator Overlay", sizeof buf, buf, false, 0
+					unFlags, "Space Calibrator Overlay", sizeof buf, buf, 0
 				);
 				keyboardOpen = true;
 			}
@@ -214,7 +249,7 @@ void RunLoop()
 				case vr::VREvent_MouseButtonUp:
 					io.MouseDown[vrEvent.data.mouse.button == vr::VRMouseButton_Left ? 0 : 1] = false;
 					break;
-				case vr::VREvent_Scroll:
+				case vr::VREvent_ScrollDiscrete:
 					io.MouseWheelH += vrEvent.data.scroll.xdelta * 360.0f * 8.0f;
 					io.MouseWheel += vrEvent.data.scroll.ydelta * 360.0f * 8.0f;
 					break;
@@ -342,7 +377,11 @@ static void HandleCommandLine(LPWSTR lpCmdLine)
 		vr::VR_Init(&vrErr, vr::VRApplication_Utility);
 		if (vrErr == vr::VRInitError_None)
 		{
-			printf("%s", vr::VR_RuntimePath());
+			char cruntimePath[MAX_PATH] = { 0 };
+			unsigned int pathLen;
+			vr::VR_GetRuntimePath(cruntimePath, MAX_PATH, &pathLen);
+
+			printf("%s", cruntimePath);
 			vr::VR_Shutdown();
 			exit(0);
 		}
@@ -421,12 +460,12 @@ static void HandleCommandLine(LPWSTR lpCmdLine)
 		{
 			try
 			{
-				WriteActivateMultipleDriversToConfig();
+				ActivateMultipleDrivers();
 				ret = 0;
 			}
 			catch (std::runtime_error &e)
 			{
-				std::cerr << "Failed to set activateMultipleDrivers: " << e.what() << std::endl;
+				std::cerr << e.what() << std::endl;
 			}
 		}
 		else

OpenVR-SpaceCalibrator/UserInterface.cpp

@@ -9,7 +9,7 @@
 #include <algorithm>
 #include <imgui/imgui.h>
 
-#define VERSION_STRING "0.8"
+#define VERSION_STRING "1.1"
 
 struct VRDevice
 {
@@ -33,35 +33,51 @@ VRState LoadVRState();
 void BuildSystemSelection(const VRState &state);
 void BuildDeviceSelections(const VRState &state);
 void BuildProfileEditor();
+void BuildMenu(bool runningInOverlay);
+
+static const ImGuiWindowFlags bareWindowFlags =
+	ImGuiWindowFlags_NoTitleBar |
+	ImGuiWindowFlags_NoResize |
+	ImGuiWindowFlags_NoMove;
 
 void BuildMainWindow(bool runningInOverlay)
 {
-	ImGuiWindowFlags windowFlags =
-		ImGuiWindowFlags_NoTitleBar |
-		ImGuiWindowFlags_NoResize |
-		ImGuiWindowFlags_NoMove;
-
 	auto &io = ImGui::GetIO();
 
 	ImGui::SetNextWindowPos(ImVec2(0.0f, 0.0f), ImGuiSetCond_Always);
 	ImGui::SetNextWindowSize(io.DisplaySize, ImGuiSetCond_Always);
 
-	if (!ImGui::Begin("MainWindow", nullptr, windowFlags))
+	if (!ImGui::Begin("MainWindow", nullptr, bareWindowFlags))
 	{
-        ImGui::End();
+		ImGui::End();
 		return;
 	}
 
-	ImGuiStyle &style = ImGui::GetStyle();
+	ImGui::PushStyleColor(ImGuiCol_PlotHistogram, ImGui::GetStyleColorVec4(ImGuiCol_Button));
 
 	auto state = LoadVRState();
 	BuildSystemSelection(state);
 	BuildDeviceSelections(state);
+	BuildMenu(runningInOverlay);
 
+	ImGui::PopStyleColor();
+	ImGui::End();
+}
+
+void BuildMenu(bool runningInOverlay)
+{
+	auto &io = ImGui::GetIO();
+	ImGuiStyle &style = ImGui::GetStyle();
 	ImGui::Text("");
 
 	if (CalCtx.state == CalibrationState::None)
 	{
+		if (CalCtx.validProfile && !CalCtx.enabled)
+		{
+			ImGui::TextColored(ImColor(0.8f, 0.2f, 0.2f), "Reference (%s) HMD not detected, profile disabled", CalCtx.referenceTrackingSystem.c_str());
+			ImGui::Text("");
+		}
+
 		float width = ImGui::GetWindowContentRegionWidth(), scale = 1.0f;
 		if (CalCtx.validProfile)
 		{
@@ -86,9 +102,8 @@ void BuildMainWindow(bool runningInOverlay)
 			ImGui::SameLine();
 			if (ImGui::Button("Clear Calibration", ImVec2(width * scale, ImGui::GetTextLineHeight() * 2)))
 			{
-				CalCtx.calibratedRotation = Eigen::Vector3d();
-				CalCtx.calibratedTranslation = Eigen::Vector3d();
-				CalCtx.validProfile = false;
+				CalCtx.Clear();
+				SaveProfile(CalCtx);
 			}
 		}
 
@@ -120,6 +135,26 @@ void BuildMainWindow(bool runningInOverlay)
 				SaveProfile(CalCtx);
 			}
 		}
+
+		ImGui::Text("");
+		auto speed = CalCtx.calibrationSpeed;
+
+		ImGui::Columns(4, NULL, false);
+		ImGui::Text("Calibration Speed");
+
+		ImGui::NextColumn();
+		if (ImGui::RadioButton(" Fast          ", speed == CalibrationContext::FAST))
+			CalCtx.calibrationSpeed = CalibrationContext::FAST;
+
+		ImGui::NextColumn();
+		if (ImGui::RadioButton(" Slow          ", speed == CalibrationContext::SLOW))
+			CalCtx.calibrationSpeed = CalibrationContext::SLOW;
+
+		ImGui::NextColumn();
+		if (ImGui::RadioButton(" Very Slow     ", speed == CalibrationContext::VERY_SLOW))
+			CalCtx.calibrationSpeed = CalibrationContext::VERY_SLOW;
+
+		ImGui::Columns(1);
 	}
 	else if (CalCtx.state == CalibrationState::Editing)
 	{
@@ -136,22 +171,6 @@ void BuildMainWindow(bool runningInOverlay)
 		ImGui::Button("Calibration in progress...", ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeight() * 2));
 	}
 
-	ImGui::SetNextWindowPos(ImVec2(20.0f, 20.0f), ImGuiSetCond_Always);
-	ImGui::SetNextWindowSize(ImVec2(io.DisplaySize.x - 40.0f, io.DisplaySize.y - 40.0f), ImGuiSetCond_Always);
-	if (ImGui::BeginPopupModal("Calibration Progress", nullptr, windowFlags))
-	{
-		ImGui::TextWrapped(CalCtx.messages.c_str());
-
-		if (CalCtx.state == CalibrationState::None)
-		{
-			ImGui::Text("");
-			if (ImGui::Button("Close", ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeight() * 2)))
-				ImGui::CloseCurrentPopup();
-		}
-
-		ImGui::EndPopup();
-	}
-
 	ImGui::SetNextWindowPos(ImVec2(10.0f, ImGui::GetWindowHeight() - ImGui::GetItemsLineHeightWithSpacing()));
 	ImGui::BeginChild("bottom line", ImVec2(ImGui::GetWindowWidth() - 20.0f, ImGui::GetItemsLineHeightWithSpacing() * 2), false);
 	ImGui::Text("OpenVR Space Calibrator v" VERSION_STRING " - by tach/pushrax");
@@ -162,7 +181,38 @@ void BuildMainWindow(bool runningInOverlay)
 	}
 	ImGui::EndChild();
 
-	ImGui::End();
+	ImGui::SetNextWindowPos(ImVec2(20.0f, 20.0f), ImGuiSetCond_Always);
+	ImGui::SetNextWindowSize(ImVec2(io.DisplaySize.x - 40.0f, io.DisplaySize.y - 40.0f), ImGuiSetCond_Always);
+	if (ImGui::BeginPopupModal("Calibration Progress", nullptr, bareWindowFlags))
+	{
+		ImGui::PushStyleColor(ImGuiCol_FrameBg, (ImVec4)ImColor(0, 0, 0));
+		for (auto &message : CalCtx.messages)
+		{
+			switch (message.type)
+			{
+			case CalibrationContext::Message::String:
+				ImGui::TextWrapped(message.str.c_str());
+				break;
+			case CalibrationContext::Message::Progress:
+				float fraction = (float)message.progress / (float)message.target;
+				ImGui::Text("");
+				ImGui::ProgressBar(fraction, ImVec2(-1.0f, 0.0f), "");
+				ImGui::SetCursorPosY(ImGui::GetCursorPosY() - ImGui::GetFontSize() - style.FramePadding.y * 2);
+				ImGui::Text(" %d%%", (int)(fraction * 100));
+				break;
+			}
+		}
+		ImGui::PopStyleColor();
+
+		if (CalCtx.state == CalibrationState::None)
+		{
+			ImGui::Text("");
+			if (ImGui::Button("Close", ImVec2(ImGui::GetWindowContentRegionWidth(), ImGui::GetTextLineHeight() * 2)))
+				ImGui::CloseCurrentPopup();
+		}
+
+		ImGui::EndPopup();
+	}
 }
 
 void BuildSystemSelection(const VRState &state)
@@ -228,13 +278,14 @@ void BuildSystemSelection(const VRState &state)
 	}
 
 	ImGui::SameLine();
-	ImGui::PushItemWidth(paneWidth);
 	ImGui::Combo("##TargetTrackingSystem", &currentTargetSystem, &targetSystems[0], (int) targetSystems.size());
 
 	if (currentTargetSystem != -1 && currentTargetSystem < targetSystems.size())
 	{
 		CalCtx.targetTrackingSystem = std::string(targetSystems[currentTargetSystem]);
 	}
+
+	ImGui::PopItemWidth();
 }
 
 void AppendSeparated(std::string &buffer, const std::string &suffix)
@@ -423,10 +474,8 @@ void BuildProfileEditor()
 	ImGui::PushItemWidth(widthF);
 	ImGui::InputDouble("##Yaw", &CalCtx.calibratedRotation(1), 0.1, 1.0, "%.8f");
 	ImGui::SameLine();
-	ImGui::PushItemWidth(widthF);
 	ImGui::InputDouble("##Pitch", &CalCtx.calibratedRotation(2), 0.1, 1.0, "%.8f");
 	ImGui::SameLine();
-	ImGui::PushItemWidth(widthF);
 	ImGui::InputDouble("##Roll", &CalCtx.calibratedRotation(0), 0.1, 1.0, "%.8f");
 
 	TextWithWidth("XLabel", "X", width);
@@ -435,14 +484,12 @@ void BuildProfileEditor()
 	ImGui::SameLine();
 	TextWithWidth("ZLabel", "Z", width);
 
-	ImGui::PushItemWidth(widthF);
 	ImGui::InputDouble("##X", &CalCtx.calibratedTranslation(0), 1.0, 10.0, "%.8f");
 	ImGui::SameLine();
-	ImGui::PushItemWidth(widthF);
 	ImGui::InputDouble("##Y", &CalCtx.calibratedTranslation(1), 1.0, 10.0, "%.8f");
 	ImGui::SameLine();
-	ImGui::PushItemWidth(widthF);
 	ImGui::InputDouble("##Z", &CalCtx.calibratedTranslation(2), 1.0, 10.0, "%.8f");
+	ImGui::PopItemWidth();
 }
 
 void TextWithWidth(const char *label, const char *text, float width)

OpenVR-SpaceCalibratorDriver/InterfaceHookInjector.cpp

@@ -9,15 +9,28 @@ static Hook<void*(*)(vr::IVRDriverContext *, const char *, vr::EVRInitError *)>
 	GetGenericInterfaceHook("IVRDriverContext::GetGenericInterface");
 
 static Hook<void(*)(vr::IVRServerDriverHost *, uint32_t, const vr::DriverPose_t &, uint32_t)>
-	TrackedDevicePoseUpdatedHook("IVRServerDriverHost005::TrackedDevicePoseUpdated");
+	TrackedDevicePoseUpdatedHook005("IVRServerDriverHost005::TrackedDevicePoseUpdated");
 
-static void DetourTrackedDevicePoseUpdated(vr::IVRServerDriverHost *_this, uint32_t unWhichDevice, const vr::DriverPose_t &newPose, uint32_t unPoseStructSize)
+static Hook<void(*)(vr::IVRServerDriverHost *, uint32_t, const vr::DriverPose_t &, uint32_t)>
+	TrackedDevicePoseUpdatedHook006("IVRServerDriverHost006::TrackedDevicePoseUpdated");
+
+static void DetourTrackedDevicePoseUpdated005(vr::IVRServerDriverHost *_this, uint32_t unWhichDevice, const vr::DriverPose_t &newPose, uint32_t unPoseStructSize)
 {
 	//TRACE("ServerTrackedDeviceProvider::DetourTrackedDevicePoseUpdated(%d)", unWhichDevice);
 	auto pose = newPose;
 	if (Driver->HandleDevicePoseUpdated(unWhichDevice, pose))
 	{
-		TrackedDevicePoseUpdatedHook.originalFunc(_this, unWhichDevice, pose, unPoseStructSize);
+		TrackedDevicePoseUpdatedHook005.originalFunc(_this, unWhichDevice, pose, unPoseStructSize);
+	}
+}
+
+static void DetourTrackedDevicePoseUpdated006(vr::IVRServerDriverHost *_this, uint32_t unWhichDevice, const vr::DriverPose_t &newPose, uint32_t unPoseStructSize)
+{
+	//TRACE("ServerTrackedDeviceProvider::DetourTrackedDevicePoseUpdated(%d)", unWhichDevice);
+	auto pose = newPose;
+	if (Driver->HandleDevicePoseUpdated(unWhichDevice, pose))
+	{
+		TrackedDevicePoseUpdatedHook006.originalFunc(_this, unWhichDevice, pose, unPoseStructSize);
 	}
 }
 
@@ -29,10 +42,18 @@ static void *DetourGetGenericInterface(vr::IVRDriverContext *_this, const char *
 	std::string iface(pchInterfaceVersion);
 	if (iface == "IVRServerDriverHost_005")
 	{
-		if (!IHook::Exists(TrackedDevicePoseUpdatedHook.name))
+		if (!IHook::Exists(TrackedDevicePoseUpdatedHook005.name))
 		{
-			TrackedDevicePoseUpdatedHook.CreateHookInObjectVTable(originalInterface, 1, &DetourTrackedDevicePoseUpdated);
-			IHook::Register(&TrackedDevicePoseUpdatedHook);
+			TrackedDevicePoseUpdatedHook005.CreateHookInObjectVTable(originalInterface, 1, &DetourTrackedDevicePoseUpdated005);
+			IHook::Register(&TrackedDevicePoseUpdatedHook005);
+		}
+	}
+	else if (iface == "IVRServerDriverHost_006")
+	{
+		if (!IHook::Exists(TrackedDevicePoseUpdatedHook006.name))
+		{
+			TrackedDevicePoseUpdatedHook006.CreateHookInObjectVTable(originalInterface, 1, &DetourTrackedDevicePoseUpdated006);
+			IHook::Register(&TrackedDevicePoseUpdatedHook006);
 		}
 	}
 

README.md

@@ -1,47 +1,47 @@
-# OpenVR-SpaceCalibrator
+# OpenVR Space Calibrator
 
-Use VR devices from one company with any other.
+Use tracked VR devices from one company with any other.
 
-This is **beta software** and may not work for you. A quick video walkthrough of the calibration process is available at https://www.youtube.com/watch?v=W3TnQd9JMl4
+This is **experimental software** and may not work for your setup. It's well-tested for the Rift with Vive trackers though, with a community of a few hundred users ([Discord][]). It also seems to work for various HMDs (Windows MR, Rift) with Vive controllers and Knuckles prototypes. A quick video of how this works using an old version (~v0.3) is available at https://www.youtube.com/watch?v=W3TnQd9JMl4.
 
-## Usage
+[Discord]: https://discord.gg/m7g2Wyj
+
+### Install
+
+Before following the directions below, download and run the installer for the [latest release](https://github.com/pushrax/OpenVR-SpaceCalibrator/releases). This will automatically set up SteamVR for use with multiple tracking systems (`activateMultipleDrivers: true`).
+
+### Usage
+
+Once Space Calibrator has a calibration, it works in the background to keep your devices configured correctly. Since v0.8, everything aside from creating the calibration is automated.
 
 ### Calibration
 
-If you don't already run a setup with multiple device types, see [Setting up SteamVR](#setting-up-steamvr).
+As part of first time setup, or when you make a change to your space (e.g. move a sensor), and occasionally as the calibration drifts over time (consumer VR tracking isn't perfectly stable), you'll need to run a calibration:
 
-1. Download and unzip the [latest release](https://github.com/pushrax/OpenVR-SpaceCalibrator/releases) of OpenVR-SpaceCalibrator.
-2. Run SteamVR, and turn on your Touch controllers and only one Vive device to use for calibration.
-3. Run OpenVR-SpaceCalibrator.
-4. Hold the left Touch controller and your Vive device in your left hand securely, like they're glued together.
-5. Click "Start Calibration"
-6. Wave your left hand around, like you're calibrating the compass on your phone. You want to get as many orientations as possible.
-7. Done! A profile will be saved automatically. You can turn on the rest of your Vive devices now.
+1. Copy the chaperone/guardian bounds from your HMD's play space. This doesn't need to be run if your HMD's play space hasn't changed since last time you copied it. __Example:__ if you're using the Rift with Vive trackers and you bump a Vive lighthouse, or if the calibration has just drifted a little, you likely don't need to run this step, but if you bump an Oculus sensor you will (after running Oculus guardian setup again).
+    1. Run SteamVR, with only devices from your HMD's tracking system powered on. __Example:__ for Rift with Vive trackers, don't turn on the trackers yet.
+    2. Confirm your chaperone/guardian is set up with the walls in the right place. If you change it later, you need to run step again.
+    3. Open SPACE CAL in the SteamVR dashboard overlay.
+    4. Click `Copy Chaperone Bounds to profile`
 
-Next time you run SteamVR, open OpenVR-SpaceCalibrator and it will load the calibration automatically and apply it devices you turn on.
+2. Calibrate devices.
+    1. Open SteamVR if you haven't already. Turn on some or all your devices.
+    2. Open SPACE CAL in the SteamVR dashboard overlay.
+    3. Select one device from the reference space on the left and one device from the target space on the right. If you turned on multiple devices from one space and can't tell which one is selected, click "Identify selected devices" to blink an LED or vibrate it. __Example:__ for Rift with Vive trackers, you'll see the Touch controllers on the left, and Vive trackers on the right. __Pro tip:__ if you turn on just one Vive tracker, you don't have to figure out which one is selected.
+    4. Hold these two devices in one hand, like they're glued together. If they slip, calibration won't work as well.
+    5. Click `Start Calibration`
+    6. Move and rotate your hand around slowly a few times, like you're calibrating the compass on your phone. You want to sample as many orientations as possible.
+    7. Done! A profile will be saved automatically. If you haven't already, turn on all your devices. Space Calibrator will automatically apply the calibration to devices as they turn on.
 
+### Calibration outside VR
 
-### Setting up SteamVR
-
-Every hardware designer with their own tracking system needs to make a "driver"
-so SteamVR can see their tracking data. SteamVR by default will load only one driver at a time,
-but we can tell it to load all of them by editing the vrsettings config file.
-
-Open `Steam\steamapps\common\SteamVR\resources\settings\default.vrsettings` in a text editor,
-look for the line that has `"activateMultipleDrivers": false` and change the `false` to `true`.
-In some guides online you may also see references to `requireHmd`, this does _not_ need to be changed
-unless you truly want to be able to run without any kind of HMD.
-
-Sometimes when SteamVR updates this file seems to get wiped, if your setup stops working you might
-have to edit the config again.
-
+You can calibrate without using the dashboard overlay by unminimizing Space Calibrator after opening SteamVR (it starts minimized). This is required if you're calibrating for a lone HMD without any devices in its tracking system.
 
 ### Compiling your own build
 
-1. Open `OpenVR-SpaceCalibrator.sln` in Visual Studio 2015 and build.
+Open `OpenVR-SpaceCalibrator.sln` in Visual Studio 2015 and build. There are no external dependencies.
 
-
-## The math
+### The math
 
 See [math.pdf](https://github.com/pushrax/OpenVR-SpaceCalibrator/blob/master/math.pdf) for details.
 If you have some ideas for how to improve the calibration process, let me know!