ui stuff + clear notifications

.gitignore

@@ -432,3 +432,6 @@ FodyWeavers.xsd
 
 # imgui
 imgui.ini
+
+# vcpkg
+vcpkg_installed/

AsuroImgui.sln

@@ -5,13 +5,13 @@ VisualStudioVersion = 17.0.32112.339
 MinimumVisualStudioVersion = 10.0.40219.1
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ImguiBase", "ImguiBase\ImguiBase.vcxproj", "{BB8A1CA3-7660-49E9-BAF1-A99F733F7DB6}"
 EndProject
-Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "ImguiNodes", "ImguiNodes\ImguiNodes.vcxproj", "{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}"
-EndProject
 Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "AsuroTool", "AsuroTool\AsuroTool.vcxproj", "{CC10396F-B66E-4240-844F-BEDCDD94E88E}"
 	ProjectSection(ProjectDependencies) = postProject
 		{BB8A1CA3-7660-49E9-BAF1-A99F733F7DB6} = {BB8A1CA3-7660-49E9-BAF1-A99F733F7DB6}
 	EndProjectSection
 EndProject
+Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Solution Items", "Solution Items", "{9124372A-4D64-4C3F-88AC-FC4356CC66F5}"
+EndProject
 Global
 	GlobalSection(SolutionConfigurationPlatforms) = preSolution
 		Debug|x64 = Debug|x64
@@ -28,14 +28,6 @@ Global
 		{BB8A1CA3-7660-49E9-BAF1-A99F733F7DB6}.Release|x64.Build.0 = Release|x64
 		{BB8A1CA3-7660-49E9-BAF1-A99F733F7DB6}.Release|x86.ActiveCfg = Release|Win32
 		{BB8A1CA3-7660-49E9-BAF1-A99F733F7DB6}.Release|x86.Build.0 = Release|Win32
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Debug|x64.ActiveCfg = Debug|x64
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Debug|x64.Build.0 = Debug|x64
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Debug|x86.ActiveCfg = Debug|Win32
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Debug|x86.Build.0 = Debug|Win32
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Release|x64.ActiveCfg = Release|x64
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Release|x64.Build.0 = Release|x64
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Release|x86.ActiveCfg = Release|Win32
-		{BE4E5CFB-C93F-41D7-B474-721AD43D51A3}.Release|x86.Build.0 = Release|Win32
 		{CC10396F-B66E-4240-844F-BEDCDD94E88E}.Debug|x64.ActiveCfg = Debug|x64
 		{CC10396F-B66E-4240-844F-BEDCDD94E88E}.Debug|x64.Build.0 = Debug|x64
 		{CC10396F-B66E-4240-844F-BEDCDD94E88E}.Debug|x86.ActiveCfg = Debug|Win32

AsuroTool/ApplicationData.cpp

@@ -1,9 +1,127 @@
 #include "ApplicationData.h"
+#include "Util.h"
+#include "AudioApi.h"
+#include <functiondiscoverykeys.h>
+
+AudioDevice::AudioDevice(IMMDevice* device, LPCWSTR deviceId) : device(device)
+{
+	id = std::wstring(deviceId);
+
+	IPropertyStore* propertyStore;
+	HRESULT err = device->OpenPropertyStore(STGM_READ, &propertyStore);
+	isError(err, "Failed to open prop store: ");
+
+	PROPVARIANT deviceNameProp;
+	const wchar_t* deviceName;
+	err = getDevicePropertyString(propertyStore, PKEY_Device_FriendlyName, &deviceNameProp, deviceName);
+	isError(err, "Failed to read name of device :");
+	name = utf8Encode(deviceName);
+
+	err = device->GetState(&state);
+	isError(err, "Failed to reat state of device: ");
+
+	err = device->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER, NULL, (LPVOID*)&volumeInterface);
+	isError(err, "Failed to get audio endpoint volume interface: ");
+
+	err = device->Activate(__uuidof(IAudioMeterInformation), CLSCTX_INPROC_SERVER, NULL, (LPVOID*)&meterInterface);
+	isError(err, "Failed to get audio meter interface: ");
+
+	if (volumeInterface != nullptr && meterInterface != nullptr)
+	{
+		getVolumeLimit(volumeInterface, &minVolumeDb, &maxVolumeDb);
+		isInitialized = true;
+	}
+
+	if (propertyStore)
+	{
+		propertyStore->Release();
+	}
+}
+
+AudioDevice::AudioDevice(AudioDevice&& other) noexcept
+	: device(other.device), volumeInterface(other.volumeInterface), meterInterface(other.meterInterface),
+	id(other.id), name(other.name), state(other.state),
+	isDefaultConsole(other.isDefaultConsole), isDefaultMedia(other.isDefaultMedia), isDefaultCommunication(other.isDefaultCommunication),
+	minVolumeDb(other.minVolumeDb), maxVolumeDb(other.maxVolumeDb)
+{
+	other.device = nullptr;
+	other.volumeInterface = nullptr;
+	other.meterInterface = nullptr;
+}
+
+AudioDevice& AudioDevice::operator=(AudioDevice&& other) noexcept
+{
+	this->device = other.device;
+	this->volumeInterface = other.volumeInterface;
+	this->meterInterface = other.meterInterface;
+	this->id = other.id;
+	this->name = other.name;
+	this->state = other.state;
+	this->isDefaultConsole = other.isDefaultConsole;
+	this->isDefaultMedia = other.isDefaultMedia;
+	this->isDefaultCommunication = other.isDefaultCommunication;
+	this->minVolumeDb = other.minVolumeDb;
+	this->maxVolumeDb = other.maxVolumeDb;
+
+	other.device = nullptr;
+	other.volumeInterface = nullptr;
+	other.meterInterface = nullptr;
+	return *this;
+}
 
 AudioDevice::~AudioDevice()
 {
+	if (volumeInterface)
+	{
+		volumeInterface->Release();
+		volumeInterface = nullptr;
+	}
+	if (meterInterface)
+	{
+		meterInterface->Release();
+		meterInterface = nullptr;
+	}
 	if (device)
 	{
-		//device->Release();
+		device->Release();
+		device = nullptr;
+	}
+}
+
+AudioData::AudioData()
+{
+}
+
+AudioData::AudioData(AudioData&& other) noexcept
+	: playbackDevices(std::move(other.playbackDevices)), recordingDevices(std::move(other.recordingDevices)),
+	deviceEnumerator(other.deviceEnumerator), audioNotificationListener(other.audioNotificationListener)
+{
+	other.deviceEnumerator = nullptr;
+	other.audioNotificationListener = nullptr;
+}
+
+AudioData& AudioData::operator=(AudioData&& other) noexcept
+{
+	playbackDevices = std::move(other.playbackDevices);
+	recordingDevices = std::move(other.recordingDevices);
+	deviceEnumerator = other.deviceEnumerator;
+	audioNotificationListener = other.audioNotificationListener;
+
+	other.deviceEnumerator = nullptr;
+	other.audioNotificationListener = nullptr;
+	return *this;
+}
+
+AudioData::~AudioData()
+{
+	if (deviceEnumerator)
+	{
+		deviceEnumerator->Release();
+		deviceEnumerator = nullptr;
+	}
+	if (audioNotificationListener)
+	{
+		audioNotificationListener->Release();
+		audioNotificationListener = nullptr;
 	}
 }

AsuroTool/ApplicationData.h

@@ -1,34 +1,90 @@
 #pragma once
 
-#include <mmdeviceapi.h>
+#include "AudioNotificationListener.h"
+#include "WindowsShell.h"
+
 #include <endpointvolume.h>
+
 #include <string>
 #include <vector>
+#include <unordered_map>
+#include <chrono>
 
 class AudioDevice {
 public:
+	bool isInitialized = false;
 	IMMDevice* device = nullptr;
 	IAudioEndpointVolume* volumeInterface = nullptr;
 	IAudioMeterInformation* meterInterface = nullptr;
 	std::wstring id = {};
 	std::string name = {};
 	unsigned long state = {};
-	bool isDefaultConsole = {};
-	bool isDefaultMedia = {};
-	bool isDefaultCommunication = {};
+	bool isDefaultConsole = false;
+	bool isDefaultMedia = false;
+	bool isDefaultCommunication = false;
+	float minVolumeDb = 0.f;
+	float maxVolumeDb = 0.f;
 
+	AudioDevice(IMMDevice* device, LPCWSTR deviceId);
+	AudioDevice(AudioDevice&& other) noexcept;
+	AudioDevice& operator=(AudioDevice&& other) noexcept;
 	~AudioDevice();
 };
 
+class AudioData {
+public:
+	std::vector<AudioDevice> playbackDevices = {};
+	std::vector<AudioDevice> recordingDevices = {};
+	IMMDeviceEnumerator* deviceEnumerator = nullptr;
+	AudioNotificationListener* audioNotificationListener = nullptr;
+
+	AudioData();
+	AudioData(AudioData&& other) noexcept;
+	AudioData& operator=(AudioData&& other) noexcept;
+	~AudioData();
+};
+
 class ApplicationSettings {
 public:
+	bool autostart = false;
+	bool docked = false;
 	bool showDisabledDevices = false;
-	bool fitWindowHeight = true;
+	bool showChecklistExtras = false;
+	std::vector<std::string> taskNames = {};
+	std::unordered_map<std::string, std::vector<std::chrono::year_month_day>> tasks = {};
+	std::vector<std::string> baseStationMacAdresses = {};
+	bool baseStationShowConsole;
+	float timerDuration = 5.f * 60.f;
+	float timerRepeatDuration = 2.f * 60.f;
+	bool timerRepeating = false;
+};
+
+enum class HoverTargetType
+{
+	HOVER_TARGET_NONE = 0,
+	HOVER_TARGET_CHECKLIST_DAY = 1,
+};
+
+struct TimerData {
+	bool isTimerActive = false;
+	std::chrono::system_clock::time_point timerStartTimestamp;
+	bool timerHasNotified = false;
+	float lastNotifySeconds;
+	TimerToastHandler toastHandler = {};
 };
 
 class ApplicationData {
 public:
 	ApplicationSettings settings = {};
-	std::vector<AudioDevice> playbackDevices = {};
-	std::vector<AudioDevice> recordingDevices = {};
+	size_t checklistLength = 0;
+	int checklistHighlightDurationDays = 3;
+	std::shared_ptr<AudioData> audioData = std::make_shared<AudioData>();
+	HoverTargetType hoverTargetType = HoverTargetType::HOVER_TARGET_NONE;
+	std::chrono::year_month_day hoverTargetDay = {};
+	TimerData timerData{};
+	std::mutex timerMutex{};
+	bool lighthouseProcActive = false;
+
+	//ApplicationData(const ApplicationData&) = delete;
+	//ApplicationData& operator=(const ApplicationData&) = delete;
 };

AsuroTool/AsuroTool.cpp

@@ -3,87 +3,202 @@
 #pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")
 #endif
 
-#include <windows.h>
-
-#include <iostream>
-#include <sstream>
+// we need commctrl v6 for LoadIconMetric()
+// see https://github.com/microsoft/Windows-classic-samples/blob/main/Samples/Win7Samples/winui/shell/appshellintegration/NotificationIcon/NotificationIcon.cpp
+#pragma comment(linker,"/manifestdependency:\"type='win32' name='Microsoft.Windows.Common-Controls' version='6.0.0.0' processorArchitecture='*' publicKeyToken='6595b64144ccf1df' language='*'\"")
+#pragma comment(lib, "comctl32.lib")
+#pragma comment(lib, "rpcrt4.lib")
 
 #include "Util.h"
 #include "AudioApi.h"
-#include "resource.h"
+#include "Settings.h"
 #include "AsuroTool.h"
+#include "WindowsShell.h"
+#include "Timer.h"
+
+#include <array>
+#include <functional>
+#include <iostream>
+#include <sstream>
+#include <format>
+using std::chrono::year_month_day;
+
+#undef min
+#undef max
+
+#define MAX_FONT_PATH_LENGTH 2048
+#define SETTINGS_POPUP_NAME "settings_popup"
+#define TIMER_WARNING_COLOR ImVec4(.7f, 0.2f, 0.2f, .5f)
+
+// Globals for use in callbacks
+DrawData* gDrawData;
+ApplicationData* gAppData;
+bool justDocked = false;
+bool isHidden = false;
+year_month_day selectedDay = {};
 
 int main()
 {
-	ApplicationData applicationData{};
+	isError(CoInitializeEx(NULL, COINIT_MULTITHREADED), "Failed to initialize");
 
-	startImgui(&applicationData, init, draw, "Asuro's Tool", 600, 400);
+	std::wstring appDir;
+	getAppDir(appDir);
+	if (_wchdir(appDir.c_str()) != 0)
+	{
+		std::cout << "Failed to set working dir." << std::endl;
+	}
+
+	ApplicationData applicationData{};
+	ImGuiCallbacks callbacks{};
+
+	callbacks.initFunc = std::bind(init, std::placeholders::_1, std::ref(applicationData));
+	callbacks.drawFunc = std::bind(draw, std::placeholders::_1, std::ref(applicationData));
+	callbacks.cleanupFunc = std::bind(cleanup, std::placeholders::_1, std::ref(applicationData));
+
+	startImgui(callbacks, "Audio Thingy", 700, 400);
 }
 
-void init(DrawData& drawData, void* customData)
+void init(DrawData& drawData, ApplicationData& appData)
 {
-	ApplicationData* appData = static_cast<ApplicationData*>(customData);
+	std::wstring appPath;
+	getAppDir(appPath);
+	char appPathStr[MAX_FONT_PATH_LENGTH];
+	HRESULT convResult = WideCharToMultiByte(CP_UTF8, NULL, &appPath[0], -1, appPathStr, MAX_FONT_PATH_LENGTH, NULL, nullptr);
+	isError(convResult, "Failed to convert path: ");
+
+	// sad :(
+	gDrawData = &drawData;
+	gAppData = &appData;
 
 	// Load text font
 	ImGuiIO& io = ImGui::GetIO();
-	io.Fonts->AddFontFromFileTTF("Montserrat-Regular.ttf", 18.0f);
+	std::string fontPath = std::string(appPathStr);
+	fontPath.append("\\Montserrat-Regular.ttf");
+	io.Fonts->AddFontFromFileTTF(fontPath.c_str(), 18.0f);
 
 	// Load icon font
 	static const ImWchar icons_ranges[] = { 0xEA01, 0xF2DF, 0 };
 	ImFontConfig icons_config;
 	icons_config.MergeMode = true;
 	icons_config.PixelSnapH = true;
-	io.Fonts->AddFontFromFileTTF("remixicon.ttf", 14.0f, &icons_config, icons_ranges);
+	icons_config.GlyphOffset = { 0., 1. };
+	std::string iconFontPath = std::string(appPathStr);
+	iconFontPath.append("\\remixicon.ttf");
+	io.Fonts->AddFontFromFileTTF(iconFontPath.c_str(), 14.0f, &icons_config, icons_ranges);
 
-	// Set up audio device api
-	HRESULT initResult = CoInitializeEx(NULL, COINIT_MULTITHREADED);
-	isError(initResult, "Failed to initialize COM: ");
+	// style
+	loadUiStyle();
 
-	reloadDeviceLists(appData);
+	// Start timer thread
+	std::thread timerThread(updateTimer, std::ref(appData));
+	timerThread.detach();
 	
-	// Set window icon
-	LPWSTR iconId = MAKEINTRESOURCE(IDI_ICON1);
-	HANDLE iconLarge = LoadImageW(GetModuleHandle(NULL), iconId, IMAGE_ICON, 64, 64, 0);
-	HANDLE iconSmall = LoadImageW(GetModuleHandle(NULL), iconId, IMAGE_ICON, 32, 32, 0);
-	SendMessage(drawData.window_handle, WM_SETICON, ICON_BIG, (LPARAM)iconLarge);
-	SendMessage(drawData.window_handle, WM_SETICON, ICON_SMALL, (LPARAM)iconSmall);
-	SendMessage(drawData.window_handle, WM_SETICON, ICON_SMALL2, (LPARAM)iconSmall);
+	// Time
+	selectedDay = std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now());
+	
+	initShell(drawData);
+	initSettings(drawData, appData);
+	initAudio(appData);
 }
 
-void draw(DrawData& drawData, void* customData)
+void draw(DrawData& drawData, ApplicationData& appData)
 {
-	ApplicationData* appData = static_cast<ApplicationData*>(customData);
-	float customYCursor = 0;
-	customYCursor += menuBar(appData).y;
+	const float panelGap = 0.f;
 
-	ImVec2 containingSize = ImGui::GetMainViewport()->Size;
+	justDocked = false;
+	appData.hoverTargetType = HoverTargetType::HOVER_TARGET_NONE;
 
-	ImGui::SetNextWindowPos(ImVec2(0, customYCursor));
-	ImGui::SetNextWindowSize(ImVec2(containingSize.x, 0));
-	customYCursor += audioDeviceWindow(appData, appData->playbackDevices, " \xEE\xB8\x84 Playback").y;
-
-	customYCursor += 5.;
-
-	ImGui::SetNextWindowPos(ImVec2(0, customYCursor));
-	ImGui::SetNextWindowSize(ImVec2(containingSize.x, 0));
-	customYCursor += audioDeviceWindow(appData, appData->recordingDevices, " \xEE\xBD\x8F Recording").y;
-
-	if (appData->settings.fitWindowHeight)
+	if (isHidden)
 	{
-		drawData.window_size.y = customYCursor;
+		glfwWaitEvents();
+		return;
+	}
+
+	float customYCursor = 0;
+	ImVec2 viewportSize = ImGui::GetMainViewport()->Size;
+
+	// Menu Bar
+	customYCursor += menuBar(drawData, appData).y;
+
+	// Checklist
+	ImGui::SetNextWindowPos(ImVec2(0, customYCursor));
+	ImGui::SetNextWindowSize(ImVec2(viewportSize.x, 0));
+	customYCursor += checklistWindow(appData, std::format(" {} Checklist", ICON_CHECK_FILL).c_str()).y;
+	customYCursor += panelGap;
+
+	// Timer
+	ImGui::SetNextWindowPos(ImVec2(0, customYCursor));
+	ImGui::SetNextWindowSize(ImVec2(viewportSize.x / 2.f - 1.f, 0));
+	float timerWindowHeight = timerWindow(drawData, appData).y;
+
+	// Base Stations
+	ImGui::SetNextWindowPos(ImVec2(viewportSize.x / 2.f, customYCursor));
+	ImGui::SetNextWindowSize(ImVec2(viewportSize.x / 2.f - 1.f, 0));
+	float baseStationWindowHeight = baseStationWindow(appData).y;
+	customYCursor += std::fmaxf(baseStationWindowHeight, timerWindowHeight);
+	customYCursor += panelGap;
+
+	// Playback Devices
+	ImGui::SetNextWindowPos(ImVec2(0, customYCursor));
+	ImGui::SetNextWindowSize(ImVec2(viewportSize.x, 0));
+	customYCursor += audioDeviceWindow(appData, appData.audioData->playbackDevices, std::format(" {} Playback", ICON_HEADPHONE_FILL).c_str()).y;
+	customYCursor += panelGap;
+
+	// Recording devices
+	ImGui::SetNextWindowPos(ImVec2(0, customYCursor));
+	ImGui::SetNextWindowSize(ImVec2(viewportSize.x, 0));
+	customYCursor += audioDeviceWindow(appData, appData.audioData->recordingDevices, std::format(" {} Recording", ICON_MIC_FILL).c_str()).y;
+
+	// Resize viewport
+	drawData.window_size.y = customYCursor;
+
+	if (appData.settings.docked)
+	{
+		int monitorX, monitorY, monitorW, monitorH;
+		glfwGetMonitorWorkarea(glfwGetPrimaryMonitor(), &monitorX, &monitorY, &monitorW, &monitorH);
+		glfwSetWindowPos(drawData.window, monitorX + monitorW - drawData.window_size.x, monitorY + monitorH - drawData.window_size.y);
+	}
+
+	// Tooltip
+	if (appData.hoverTargetType == HoverTargetType::HOVER_TARGET_CHECKLIST_DAY)
+	{
+		ImGui::BeginTooltip();
+		ImGui::Text(std::format("{:%a, %d.%m}", std::chrono::sys_days{ appData.hoverTargetDay }).c_str());
+		ImGui::EndTooltip();
 	}
 }
 
-ImVec2 menuBar(ApplicationData* appData)
+void cleanup(DrawData& drawData, ApplicationData& appData)
+{
+	cleanupShell(drawData);
+}
+
+float getButtonWidth(const char* label)
+{
+	ImVec2 labelSize = ImGui::CalcTextSize(label);
+	return labelSize.x + ImGui::GetStyle().FramePadding.x * 2.f;
+}
+
+ImVec2 menuBar(DrawData& drawData, ApplicationData& appData)
 {
 	ImVec2 size{};
+	bool closeMenu = false;
 
 	if (ImGui::BeginMainMenuBar())
 	{
 		if (ImGui::BeginMenu("Settings"))
 		{
-			ImGui::Checkbox("Show Disabled Devices", &appData->settings.showDisabledDevices);
-			ImGui::Checkbox("Fit Window Height", &appData->settings.fitWindowHeight);
+			if (ImGui::Checkbox("Docked", &appData.settings.docked))
+			{
+				closeMenu = true;
+				updateDocked(drawData, appData);
+			}
+
+			if (ImGui::Checkbox("Autostart", &appData.settings.autostart))
+			{
+				setAutostart(appData.settings.autostart);
+			}
+
 			ImGui::EndMenu();
 		}
 
@@ -91,14 +206,46 @@ ImVec2 menuBar(ApplicationData* appData)
 		{
 			if (ImGui::Button("Manual Refresh"))
 			{
-				reloadDeviceLists(appData);
+				reloadDeviceLists(*appData.audioData);
 			}
+			ImGui::Text("setup: %.1f ms", drawData.frameTimeSetup);
+			ImGui::Text("draw: %.1f ms", drawData.frameTimeDraw);
+			ImGui::Text("render: %.1f ms", drawData.frameTimeRender);
+			ImGui::Text("display: %.1f ms", drawData.frameTimeDisplay);
 			ImGui::EndMenu();
 		}
+		
+		if (ImGui::BeginMenu("Style"))
+		{
+			ImGui::ShowStyleEditor();
+			ImGui::EndMenu();
+		}
+
+		if (appData.settings.docked)
+		{
+			ImVec2 availableSpace = ImGui::GetContentRegionAvail();
+			ImVec2 cursorPos = ImGui::GetCursorPos();
+			ImGui::SetCursorPosX(cursorPos.x + availableSpace.x - getButtonWidth(ICON_SUBTRACT_FILL) * 2.f);
+
+			if (ImGui::SmallButton(ICON_SUBTRACT_FILL))
+			{
+				glfwIconifyWindow(drawData.window);
+			}
+			if (ImGui::SmallButton(ICON_CLOSE_FILL))
+			{
+				glfwSetWindowShouldClose(drawData.window, GLFW_TRUE);
+			}
+		}
+
 		size = ImGui::GetWindowSize();
 		ImGui::EndMainMenuBar();
 	}
 
+	if (closeMenu)
+	{
+		ImGui::SetWindowFocus();
+	}
+
 	return size;
 }
 
@@ -111,7 +258,7 @@ bool customButton(const char* id_start, const char* id_end, const char* title, b
 	if (visible)
 	{
 		ImGui::PushID(buttonId.c_str());
-		result = ImGui::SmallButton(title);
+		result = dropButton(title, {}, 2.f, true);
 		ImGui::PopID();
 	}
 	else
@@ -122,16 +269,535 @@ bool customButton(const char* id_start, const char* id_end, const char* title, b
 	return result;
 }
 
-ImVec2 audioDeviceWindow(ApplicationData* appData, std::vector<AudioDevice>& deviceList, const char* title)
+bool windowHeaderButton(const char* id)
+{
+	ImRect tempRect = ImGui::GetCurrentWindow()->ClipRect;
+	ImVec2 tempPos = ImGui::GetCursorPos();
+	ImVec2 windowMax = ImGui::GetWindowContentRegionMax();
+	ImGui::PopClipRect();
+
+	ImGuiStyle style = ImGui::GetStyle();
+	ImGui::SetCursorPos({ windowMax.x - getButtonWidth(ICON_CLOSE_FILL), tempPos.y - style.WindowPadding.y - 22.f });
+	bool result = dropButton(id, ImVec2{}, 1.f, true);
+
+	ImGui::PushClipRect(tempRect.Min, tempRect.Max, false);
+	ImGui::SetCursorPos(tempPos);
+
+	return result;
+}
+
+void drawChecklistDayLines(ApplicationData& appData, ImDrawList* drawList, float lineHeight, year_month_day day)
+{
+	for (std::string& taskName : appData.settings.taskNames)
+	{
+		ImVec2 cursorPos = ImGui::GetCursorScreenPos();
+		ImColor color;
+		auto& tasks = appData.settings.tasks[taskName];
+
+		if (std::any_of(tasks.begin(), tasks.end(), [&](year_month_day taskDay) { return taskDay == day; }))
+		{
+			color = ImColor{ .4f, .9f, .3f };
+		}
+		else
+		{
+			color = ImColor{ .1f, .3f, .05f };
+		}
+
+		drawList->AddLine({ cursorPos.x, cursorPos.y }, { cursorPos.x, cursorPos.y + lineHeight }, color, DAY_LINE_WIDTH);
+		ImGui::SetCursorScreenPos({ cursorPos.x + DAY_LINE_OFFSET, cursorPos.y });
+	}
+}
+
+void drawDayLineButton(ApplicationData& appData, ImDrawList* drawList, float lineHeight, year_month_day day, bool drawRect = true)
+{
+	ImVec2 pos = ImGui::GetCursorScreenPos();
+	ImVec2 startPos = { pos.x - DAY_OUTLINE_SIZE, pos.y - DAY_OUTLINE_SIZE };
+	size_t taskCount = appData.settings.taskNames.size();
+	ImVec2 size = { DAY_LINE_OFFSET * taskCount + DAY_OUTLINE_SIZE, lineHeight + DAY_OUTLINE_SIZE * 2.f };
+	ImVec2 endPos = { startPos.x + size.x, startPos.y + size.y };
+	ImGui::SetCursorScreenPos(startPos);
+
+	if (selectedDay == day)
+	{
+		if (drawRect) drawList->AddRect(startPos, endPos, ImColor(1.f, 1.f, 1.f));
+	}
+	else if (ImGui::InvisibleButton(std::format("daybn_{}", day).c_str(), size))
+	{
+		selectedDay = day;
+	}
+	ImGui::SetCursorScreenPos(pos);
+
+	if (ImGui::IsMouseHoveringRect(startPos, endPos, false))
+	{
+		appData.hoverTargetType = HoverTargetType::HOVER_TARGET_CHECKLIST_DAY;
+		appData.hoverTargetDay = day;
+	}
+}
+
+void setTimerDuration(ApplicationData& appData, int timerEndHours, int timerEndMinutes, tm& timeInfo)
+{
+	timeInfo.tm_hour = timerEndHours;
+	timeInfo.tm_min = timerEndMinutes;
+	TimePoint newEndTime = std::chrono::system_clock::from_time_t(mktime(&timeInfo));
+
+	if (newEndTime < std::chrono::system_clock::now())
+	{
+		newEndTime += std::chrono::days(1);
+	}
+	else if (newEndTime > std::chrono::system_clock::now() + std::chrono::days(1))
+	{
+		newEndTime -= std::chrono::days(1);
+	}
+
+	appData.settings.timerDuration = std::chrono::duration_cast<std::chrono::seconds>(newEndTime - std::chrono::system_clock::now()).count();
+}
+
+ImVec2 timerWindow(DrawData& drawData, ApplicationData& appData)
+{
+	appData.timerMutex.lock();
+	TimerData& timerData = appData.timerData;
+	
+	std::string title;
+	if (timerData.isTimerActive)
+	{
+		if (timerData.timerHasNotified)
+		{
+			title = std::format("{} Timer done!", ICON_TIMER_FILL);
+		}
+		else
+		{
+			float elapsedMinutes = calcElapsedSeconds(timerData.timerStartTimestamp) / 60.f;
+			title = std::format("{} Timer ({:.0f}/{:.0f} minutes)", ICON_TIMER_FILL, elapsedMinutes, appData.settings.timerDuration / 60.f);
+		}
+	}
+	else
+	{
+		title = std::format("{} Timer", ICON_TIMER_FILL);
+	}
+
+	// Draw window
+	if (ImGui::Begin(title.c_str(), 0, ImGuiWindowFlags_NoResize))
+	{
+		dropShadowWindowTitle();
+		if (windowHeaderButton(ICON_SETTINGS_FILL))
+		{
+			ImGui::OpenPopup(SETTINGS_POPUP_NAME);
+		}
+
+		float timerDisplayMinutes = appData.settings.timerDuration / 60.f;
+		
+		if (timerData.isTimerActive)
+		{
+			float elapsedSeconds = calcElapsedSeconds(timerData.timerStartTimestamp);
+			float timerPercentComplete = elapsedSeconds / appData.settings.timerDuration;
+			float timerDisplayPercent = timerPercentComplete;
+			timerDisplayMinutes = (appData.settings.timerDuration - elapsedSeconds) / 60.f;
+			if (timerDisplayMinutes < 0.f) timerDisplayMinutes = 0.f;
+
+			// Draw background rectangle
+			ImVec2 padding = ImGui::GetStyle().WindowPadding;
+			ImVec2 contentMin = ImGui::GetWindowContentRegionMin();
+			ImVec2 contentMax = ImGui::GetWindowContentRegionMax();
+			ImVec2 windowPos = ImGui::GetWindowPos();
+
+			ImVec2 rectMin = { contentMin.x + windowPos.x - padding.x, contentMin.y + windowPos.y - padding.y };
+			ImVec2 rectMax = { contentMax.x + windowPos.x + padding.x, contentMax.y + windowPos.y + padding.y };
+			if (timerDisplayMinutes > 0.f)
+			{
+				float contentWidth = rectMax.x - rectMin.x;
+				rectMax = { rectMin.x + contentWidth * (1.f - timerDisplayPercent), rectMax.y };
+			}
+
+			ImDrawList* drawList = ImGui::GetWindowDrawList();
+			ImRect tempRect = ImGui::GetCurrentWindow()->ClipRect;
+			ImGui::PopClipRect();
+			drawList->AddRectFilled(rectMin, rectMax, ImColor{ timerDisplayMinutes > 0.f ? ImGui::GetStyleColorVec4(ImGuiCol_TabUnfocusedActive) : TIMER_WARNING_COLOR });
+			ImGui::PushClipRect(tempRect.Min, tempRect.Max, false);
+		}
+
+		// Play/Reset
+		if (dropButton(timerData.isTimerActive ? ICON_RESTART_LINE : ICON_PLAY_FILL))
+		{
+			if (!timerData.isTimerActive)
+			{
+				timerData.isTimerActive = true;
+				timerData.timerHasNotified = false;
+				timerData.timerStartTimestamp = std::chrono::system_clock::now();
+			}
+			else
+			{
+				timerData.isTimerActive = false;
+				WinToast::instance()->clear();
+			}
+		}
+		
+		// Timer controls
+		ImGui::SameLine();
+		ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 5.f);
+		
+		if (dropButton(ICON_SUBTRACT_FILL))
+		{
+			appData.settings.timerDuration -= 60.f;
+			if (appData.settings.timerDuration < 0.) appData.settings.timerDuration = 0.f;
+		}
+		
+		ImGui::SameLine();
+		const char* durationFormatStr = "%.0fm";
+		ImGui::PushItemWidth(calcInputWidth(durationFormatStr, timerDisplayMinutes));
+		if (ImGui::DragFloat("##timer", &timerDisplayMinutes, .1f, 0.f, 1000.f, durationFormatStr))
+		{
+			appData.settings.timerDuration = timerDisplayMinutes * 60.f;
+		}
+		dropShadow();
+		ImGui::PopItemWidth();
+		
+		ImGui::SameLine();
+		if (dropButton(ICON_ADD_FILL))
+		{
+			appData.settings.timerDuration += 60.f;
+		}
+
+		ImGui::SameLine();
+
+		TimePoint endTime;
+		const char* endTimeText;
+		
+		if (timerData.isTimerActive)
+		{
+			if (timerData.timerHasNotified)
+			{
+				endTime = timerData.timerStartTimestamp + std::chrono::seconds((int)appData.settings.timerDuration);
+				endTimeText = "Ended";
+			}
+			else
+			{
+				endTime = appData.timerData.timerStartTimestamp + std::chrono::seconds((int)appData.settings.timerDuration);
+				endTimeText = "Ends";
+			}
+		}
+		else
+		{
+			endTime = std::chrono::system_clock::now() + std::chrono::seconds((int)appData.settings.timerDuration);
+			endTimeText = "Ends";
+		}
+
+		const time_t tTime = std::chrono::system_clock::to_time_t(endTime);
+		tm timeInfo;
+		localtime_s(&timeInfo, &tTime);
+		int timerEndHours = timeInfo.tm_hour;
+		int timerEndMinutes = timeInfo.tm_min;
+
+		const char* hourInputFormat = "%d";
+		float hourDragWidth = calcInputWidth(hourInputFormat, timerEndHours);
+
+		const char* minuteInputFormat = "%02d";
+		float minuteDragWidth = calcInputWidth(minuteInputFormat, timerEndMinutes);
+
+		ImGuiStyle style = ImGui::GetStyle();
+		float requiredWidth = ImGui::CalcTextSize(endTimeText).x + style.ItemSpacing.x + hourDragWidth + style.ItemSpacing.x + minuteDragWidth + 2.f;
+		float spaceWidth = ImGui::GetContentRegionAvail().x - requiredWidth;
+		ImGui::SetCursorPosX(ImGui::GetCursorPosX() + spaceWidth);
+
+		ImGui::Text("%s", endTimeText);
+		ImGui::SameLine();
+		ImGui::SetNextItemWidth(hourDragWidth);
+		if (ImGui::DragInt("##timerEndHours", &timerEndHours, .1f, 0, 23, hourInputFormat, ImGuiInputTextFlags_CharsDecimal))
+		{
+			setTimerDuration(appData, timerEndHours, timerEndMinutes, timeInfo);
+		}
+		dropShadow();
+
+		ImGui::SameLine();
+		ImGui::SetNextItemWidth(minuteDragWidth);
+		if (ImGui::DragInt("##timerEndMinutes", &timerEndMinutes, .2f, 0, 59, minuteInputFormat, ImGuiInputTextFlags_CharsDecimal))
+		{
+			setTimerDuration(appData, timerEndHours, timerEndMinutes, timeInfo);
+		}
+		dropShadow();
+	}
+
+	if (ImGui::BeginPopup(SETTINGS_POPUP_NAME))
+	{
+		// Loop
+		ImGui::Checkbox("Loop", &appData.settings.timerRepeating);
+
+		ImGui::SameLine();
+		float loopTimerMinutes = appData.settings.timerRepeatDuration / 60.f;
+		ImGui::PushItemWidth(35.f);
+		if (ImGui::InputFloat("##timerloop", &loopTimerMinutes, 0, 0, "%.0fm"))
+		{
+			appData.settings.timerRepeatDuration = loopTimerMinutes * 60.f;
+		}
+		ImGui::PopItemWidth();
+
+		ImGui::EndPopup();
+	}
+	appData.timerMutex.unlock();
+
+	ImVec2 size = ImGui::GetWindowSize();
+	ImGui::End();
+	return size;
+}
+
+ImVec2 checklistWindow(ApplicationData& appData, const char* title)
 {
 	if (ImGui::Begin(title, 0, ImGuiWindowFlags_NoResize))
 	{
-		if (ImGui::BeginTable("DeviceTable", 3, ImGuiTableFlags_Resizable | ImGuiTableFlags_Borders | ImGuiTableFlags_NoSavedSettings))
+		dropShadowWindowTitle();
+		if (windowHeaderButton(ICON_SETTINGS_FILL))
+		{
+			ImGui::OpenPopup(SETTINGS_POPUP_NAME);
+		}
+
+		// Previous days
+		ImDrawList* drawList = ImGui::GetWindowDrawList();
+		float lineHeight = ImGui::GetFontSize() + ImGui::GetStyle().FramePadding.y * 2;
+
+		for (int pastDay = 3; pastDay >= 1; pastDay--)
+		{
+			TimePoint now = std::chrono::system_clock::now();
+			TimePoint selectedDay = now - std::chrono::days{ pastDay };
+			year_month_day date = std::chrono::floor<std::chrono::days>(selectedDay);
+
+			drawDayLineButton(appData, drawList, lineHeight, date);
+			drawChecklistDayLines(appData, drawList, lineHeight, date);
+
+			ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 5.f);
+		}
+
+		// Current day
+		ImVec2 cursorPos = ImGui::GetCursorScreenPos();
+		drawList->AddLine({ cursorPos.x, cursorPos.y - 2.f }, { cursorPos.x, cursorPos.y + lineHeight + 2.f }, IM_COL32_WHITE, 1.f);
+		
+		ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 10.f);
+
+		year_month_day today = std::chrono::floor<std::chrono::days>(std::chrono::system_clock::now());
+		drawDayLineButton(appData, drawList, lineHeight, today, false);
+		drawChecklistDayLines(appData, drawList, lineHeight, today);
+
+		// Checkboxes
+		ImGui::SetCursorPosX(ImGui::GetCursorPosX() + 10.f);
+
+		auto selectedDayMatcher = [&](year_month_day taskDay) { return taskDay == selectedDay; };
+
+		for (std::string& taskName : appData.settings.taskNames)
+		{
+			if (!appData.settings.tasks.contains(taskName))
+			{
+				appData.settings.tasks.insert({ taskName, std::vector<year_month_day>{} });
+			}
+
+			std::vector<year_month_day>& taskDates = appData.settings.tasks[taskName];
+			bool taskDone = std::any_of(taskDates.begin(), taskDates.end(), selectedDayMatcher);
+			bool highlightButton = false;
+			std::string hoverText = "";
+
+			if (taskDates.size() > 0)
+			{
+				year_month_day mostRecentDoneDate = *std::max_element(taskDates.begin(), taskDates.end());
+				std::chrono::days timeDiffDays = std::chrono::round<std::chrono::days>(std::chrono::sys_days{ today } - std::chrono::sys_days{ mostRecentDoneDate });
+				highlightButton = timeDiffDays > std::chrono::days{ appData.checklistHighlightDurationDays };
+				hoverText = std::format("{}", timeDiffDays.count());
+			}
+			
+			if (highlightButton)
+			{
+				ImGui::PushStyleColor(ImGuiCol_FrameBg,        { .5f, .2f, .15f, 0.54f });
+				ImGui::PushStyleColor(ImGuiCol_FrameBgActive,  { .6f, .3f, .2f,  0.40f });
+				ImGui::PushStyleColor(ImGuiCol_FrameBgHovered, { .6f, .3f, .2f,  0.67f });
+			}
+			
+			ImVec2 beforeCheckbox = ImGui::GetCursorScreenPos();
+			std::string checkboxText = std::format("{}##taskcheck{}", taskName.c_str(), taskName.c_str());
+			if (checkboxWithDropShadow(checkboxText.c_str(), &taskDone))
+			{
+				if (taskDone)
+				{
+					taskDates.push_back(selectedDay);
+				}
+				else
+				{
+					std::erase_if(taskDates, selectedDayMatcher);
+				}
+			}
+			ImGui::SameLine(0.f, 10.f);
+			
+			if (highlightButton)
+			{
+				ImGui::PopStyleColor(3);
+
+				ImVec2 afterCheckbox = ImGui::GetCursorScreenPos();
+				float textWidth = ImGui::CalcTextSize(hoverText.c_str()).x;
+				ImGui::SetCursorScreenPos({ beforeCheckbox.x + ImGui::GetFrameHeight() / 2.f - textWidth / 2.f, beforeCheckbox.y });
+				ImGui::PushStyleColor(ImGuiCol_Text, { 1.f, 1.f, 1.f, 1.f });
+				ImGui::Text(hoverText.c_str());
+				ImGui::PopStyleColor();
+				ImGui::SetCursorScreenPos(afterCheckbox);
+			}
+		}
+
+		// Popup
+		if (ImGui::BeginPopup(SETTINGS_POPUP_NAME))
+		{
+			ImGui::Text("Task Highlight Duration");
+			ImGui::SameLine();
+
+			ImGui::PushItemWidth(75.f);
+			ImGui::DragInt("##taskduration", &appData.checklistHighlightDurationDays, .05f, 1, 7, "%d days");
+			ImGui::PopItemWidth();
+
+			ImGui::Text("Tasks");
+			auto taskIterator = appData.settings.taskNames.begin();
+			while (taskIterator != appData.settings.taskNames.end())
+			{
+				size_t taskIndex = taskIterator - appData.settings.taskNames.begin();
+				std::string& taskName = *taskIterator;
+				taskName.reserve(128);
+				ImGui::InputText(std::format("##taskinput{}", taskIndex).c_str(), taskName.data(), taskName.capacity());
+				ImGui::SameLine();
+				if (ImGui::SmallButton(std::format("{}##deltask{}", ICON_CLOSE_FILL, taskIndex).c_str()))
+				{
+					taskIterator = appData.settings.taskNames.erase(taskIterator);
+				}
+				else
+				{
+					taskIterator++;
+				}
+			}
+
+			if (ImGui::Button(ICON_ADD_FILL))
+			{
+				appData.settings.taskNames.push_back("");
+			}
+
+			ImGui::EndPopup();
+		}
+	}
+
+	ImVec2 size = ImGui::GetWindowSize();
+	ImGui::End();
+	return size;
+}
+
+void startBaseStationProc(ApplicationData& appData, const char* args, DWORD flags = 0)
+{
+	if (appData.lighthouseProcActive) return;
+	appData.lighthouseProcActive = true;
+
+	SECURITY_ATTRIBUTES saAttr;
+	saAttr.nLength = sizeof(SECURITY_ATTRIBUTES);
+	saAttr.bInheritHandle = TRUE;
+	saAttr.lpSecurityDescriptor = NULL;
+
+	HANDLE exeOutWrite;
+	HANDLE exeOutRead;
+	CreatePipe(&exeOutRead, &exeOutWrite, &saAttr, 0);
+	SetHandleInformation(exeOutRead, HANDLE_FLAG_INHERIT, 0);
+
+	// additional information
+	STARTUPINFOA si;
+	PROCESS_INFORMATION pi;
+
+	// set the size of the structures
+	ZeroMemory(&si, sizeof(si));
+	si.cb = sizeof(si);
+	si.hStdOutput = exeOutWrite;
+	si.dwFlags = STARTF_USESTDHANDLES;
+	ZeroMemory(&pi, sizeof(pi));
+
+	// start the program up
+	CreateProcessA("lighthouse-v2-manager.exe", const_cast<LPSTR>(args), NULL, NULL, true, flags, NULL, NULL, &si, &pi);
+	
+	WaitForSingleObject(pi.hProcess, INFINITE);
+
+	for (;;)
+	{
+		constexpr size_t BUFFER_SIZE = 4096;
+		char readBuffer[BUFFER_SIZE]{};
+		DWORD readCount = 0;
+		bool readSuccess = ReadFile(exeOutRead, readBuffer, BUFFER_SIZE, &readCount, NULL);
+		if (!readSuccess || readCount == 0) break;
+
+		std::cout << readBuffer << std::endl;
+	}
+
+	// Close process and thread handles. 
+	CloseHandle(pi.hProcess);
+	CloseHandle(pi.hThread);
+	CloseHandle(exeOutWrite);
+	CloseHandle(exeOutRead);
+
+	appData.lighthouseProcActive = false;
+}
+
+ImVec2 baseStationWindow(ApplicationData& appData)
+{
+	if (ImGui::Begin(std::format("{} Base Stations", ICON_ALARM_WARNING_FILL).c_str(), 0, ImGuiWindowFlags_NoResize))
+	{
+		dropShadowWindowTitle();
+		if (windowHeaderButton(ICON_SETTINGS_FILL))
+		{
+			ImGui::OpenPopup(SETTINGS_POPUP_NAME);
+		}
+
+		if (dropButton("Wake"))
+		{
+			std::string params{ " on" };
+			for (std::string& mac : appData.settings.baseStationMacAdresses)
+			{
+				params.append(" ");
+				params.append(mac.c_str());
+			}
+			startBaseStationProc(appData, params.c_str(), appData.settings.baseStationShowConsole ? CREATE_NEW_CONSOLE : CREATE_NO_WINDOW);
+		}
+		ImGui::SameLine();
+		if (dropButton("Shutdown"))
+		{
+			std::string params{ " off" };
+			for (std::string& mac : appData.settings.baseStationMacAdresses)
+			{
+				params.append(" ");
+				params.append(mac.c_str());
+			}
+			startBaseStationProc(appData, params.c_str(), appData.settings.baseStationShowConsole ? CREATE_NEW_CONSOLE : CREATE_NO_WINDOW);
+		}
+	}
+
+	if (ImGui::BeginPopup(SETTINGS_POPUP_NAME))
+	{
+		ImGui::Checkbox("Show Console", &appData.settings.baseStationShowConsole);
+		if (ImGui::Button("Search"))
+		{
+			startBaseStationProc(appData, "discover");
+			// TODO: parse stuff (annoying)
+		}
+		ImGui::Text(std::format("Known: {}", appData.settings.baseStationMacAdresses.size()).c_str());
+		ImGui::EndPopup();
+	}
+	
+	ImVec2 size = ImGui::GetWindowSize();
+	ImGui::End();
+	return size;
+}
+
+ImVec2 audioDeviceWindow(ApplicationData& appData, std::vector<AudioDevice>& deviceList, const char* title)
+{
+	if (ImGui::Begin(title, 0, ImGuiWindowFlags_NoResize))
+	{
+		dropShadowWindowTitle();
+		if (windowHeaderButton(ICON_SETTINGS_FILL))
+		{
+			ImGui::OpenPopup(SETTINGS_POPUP_NAME);
+		}
+
+		if (ImGui::BeginTable("DeviceTable", 4, ImGuiTableFlags_BordersInnerH | ImGuiTableFlags_NoSavedSettings))
 		{
 			ImGui::TableSetupColumn("Devices", ImGuiTableColumnFlags_WidthStretch, 3.);
 			ImGui::TableSetupColumn("Volume", ImGuiTableColumnFlags_WidthStretch, 1.);
-			ImGui::TableSetupColumn("Defaults", ImGuiTableColumnFlags_WidthFixed, 55.);
-			ImGui::TableHeadersRow();
+			ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed, getButtonWidth(ICON_MUSIC_2_FILL));
+			ImGui::TableSetupColumn("", ImGuiTableColumnFlags_WidthFixed, getButtonWidth(ICON_PHONE_FILL));
+
+			dropShadowTableHeadersRow();
 
 			for (auto& dev : deviceList)
 			{
@@ -141,7 +807,7 @@ ImVec2 audioDeviceWindow(ApplicationData* appData, std::vector<AudioDevice>& dev
 				{
 					ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1., 1., 1., 1.));
 				}
-				else if (!appData->settings.showDisabledDevices)
+				else if (!appData.settings.showDisabledDevices)
 				{
 					continue;
 				}
@@ -152,44 +818,108 @@ ImVec2 audioDeviceWindow(ApplicationData* appData, std::vector<AudioDevice>& dev
 
 				ImGui::TableNextRow();
 				ImGui::TableNextColumn();
+				float yPosTemp = ImGui::GetCursorPosY();
+				const float yPosOffset = 4.f;
 
+				// Device Name
+				ImGui::SetCursorPosY(yPosTemp + yPosOffset);
 				ImGui::Text(dev.name.c_str());
+				ImGui::SetCursorPosY(yPosTemp);
 
+				// Volume
 				ImGui::TableNextColumn();
+
 				if (dev.state == DEVICE_STATE_ACTIVE)
 				{
-					float volume = log10f(getMeterValue(dev.meterInterface) * 9. + 1.);
+					float startCursorY = ImGui::GetCursorPosY();
+
+					// Mute button
+					ImGui::PushID(std::string("bn_mute_").append(deviceIdUtf8).c_str());
+					ImGui::SetCursorPosY(yPosTemp + yPosOffset);
+					
+					bool isDeviceMuted = isMuted(dev.volumeInterface);
+					if (dropButton(isDeviceMuted ? ICON_VOLUME_MUTE_FILL : ICON_VOLUME_UP_FILL, {}, 2.f, true))
+					{
+						setMuted(dev.volumeInterface, !isDeviceMuted);
+					}
+
+					ImGui::PopID();
+					ImGui::SameLine();
+					ImGui::SetCursorPosY(startCursorY);
+
+					// Meter
+					static std::array<float, 2> meterValues{};
+					UINT channelCount = getMeterValues(dev.meterInterface, meterValues);
 
 					auto drawList = ImGui::GetWindowDrawList();
 					ImVec2 windowPos = ImGui::GetWindowPos();
 					ImVec2 cursorPos = ImGui::GetCursorScreenPos();
 					ImVec2 space = ImGui::GetContentRegionAvail();
-					float lineY = cursorPos.y + ImGui::GetTextLineHeight() / 2.;
+					float lineY = cursorPos.y + ImGui::GetTextLineHeight() / 2. + 2.;
 
-					drawList->AddLine(ImVec2(cursorPos.x, lineY), ImVec2(cursorPos.x + space.x, lineY), IM_COL32(120, 120, 120, 255), 2.);
-					drawList->AddLine(ImVec2(cursorPos.x, lineY), ImVec2(cursorPos.x + space.x * volume, lineY), IM_COL32(200, 200, 255, 255), 3.);
+					const float linePaddingX = 3.;
+					cursorPos.x += linePaddingX;
+					
+					// BG line
+					drawList->AddLine(ImVec2(cursorPos.x, lineY), ImVec2(cursorPos.x + (space.x - 2. * linePaddingX), lineY), IM_COL32(120, 120, 120, 255), 2.);
+
+					// Channel lines
+					if (channelCount == 1)
+					{
+						drawList->AddLine(ImVec2(cursorPos.x, lineY), ImVec2(cursorPos.x + (space.x - 2. * linePaddingX) * meterValues[0], lineY), IM_COL32(200, 200, 255, 255), 3.);
+					}
+					if (channelCount == 2)
+					{
+						drawList->AddLine(ImVec2(cursorPos.x, lineY - 2), ImVec2(cursorPos.x + (space.x - 2. * linePaddingX) * meterValues[0], lineY - 2), IM_COL32(200, 200, 255, 255), 3.);
+						drawList->AddLine(ImVec2(cursorPos.x, lineY + 2), ImVec2(cursorPos.x + (space.x - 2. * linePaddingX) * meterValues[1], lineY + 2), IM_COL32(200, 200, 255, 255), 3.);
+					}
+
+					ImGui::SetNextItemWidth(space.x);
+					ImGui::PushID(&dev.id);
+					ImGui::PushStyleColor(ImGuiCol_FrameBg, ImVec4(0, 0, 0, 0));
+					if (isDeviceMuted) ImGui::PushStyleColor(ImGuiCol_SliderGrab, ImVec4(.4, .4, .4, 1.));
+
+					float volume = getVolume(dev.volumeInterface);
+					if (ImGui::SliderFloat("", &volume, 0., 1., "", ImGuiSliderFlags_NoRoundToFormat | ImGuiSliderFlags_AlwaysClamp))
+					{
+						setVolume(dev.volumeInterface, volume);
+					}
+
+					if (isDeviceMuted) ImGui::PopStyleColor();
+					ImGui::PopStyleColor();
+					ImGui::PopID();
 				}
 
+				// Defaults
+				const float circleSize = 5.f;
+
 				ImGui::TableNextColumn();
 				if (dev.state == DEVICE_STATE_ACTIVE)
 				{
 					if (dev.isDefaultConsole)
 					{
-						drawCircle(5, IM_COL32(50, 50, 222, 255));
+						ImGui::SetCursorPosX(ImGui::GetCursorPosX() + getButtonWidth(ICON_MUSIC_2_FILL) / 2.f - circleSize);
+						ImGui::SetCursorPosY(yPosTemp + yPosOffset);
+						drawCircle(circleSize, IM_COL32(50, 50, 222, 255));
 					}
-					if (customButton("bn_d_", deviceIdUtf8.c_str(), "\xEE\xBE\x82", !dev.isDefaultConsole))
+					if (customButton("bn_d_", deviceIdUtf8.c_str(), ICON_MUSIC_2_FILL, !dev.isDefaultConsole))
 					{
-						setDefaultAudioDevice(appData, dev.id.c_str(), ERole::eConsole);
+						setDefaultAudioDevice(*appData.audioData, dev.id.c_str(), ERole::eConsole);
 					}
+				}
 
-					ImGui::SameLine();
+				ImGui::TableNextColumn();
+				if (dev.state == DEVICE_STATE_ACTIVE)
+				{
 					if (dev.isDefaultCommunication)
 					{
-						drawCircle(5, IM_COL32(222, 50, 50, 255));
+						ImGui::SetCursorPosX(ImGui::GetCursorPosX() + getButtonWidth(ICON_PHONE_FILL) / 2.f - circleSize);
+						ImGui::SetCursorPosY(yPosTemp + yPosOffset);
+						drawCircle(circleSize, IM_COL32(222, 50, 50, 255));
 					}
-					if (customButton("bn_c_", deviceIdUtf8.c_str(), "\xEE\xBF\xA9", !dev.isDefaultCommunication))
+					if (customButton("bn_c_", deviceIdUtf8.c_str(), ICON_PHONE_FILL, !dev.isDefaultCommunication))
 					{
-						setDefaultAudioDevice(appData, dev.id.c_str(), ERole::eCommunications);
+						setDefaultAudioDevice(*appData.audioData, dev.id.c_str(), ERole::eCommunications);
 					}
 				}
 
@@ -200,6 +930,12 @@ ImVec2 audioDeviceWindow(ApplicationData* appData, std::vector<AudioDevice>& dev
 		}
 	}
 
+	if (ImGui::BeginPopup(SETTINGS_POPUP_NAME))
+	{
+		ImGui::Checkbox("Show Disabled Devices", &appData.settings.showDisabledDevices);
+		ImGui::EndPopup();
+	}
+
 	ImVec2 size = ImGui::GetWindowSize();
 
 	ImGui::End();

AsuroTool/AsuroTool.h

@@ -1,12 +1,24 @@
 #pragma once
 
-#include <vector>
-
 #include "ImguiBase.h"
 #include "ApplicationData.h"
 
-void init(DrawData& drawData, void* customData);
-void draw(DrawData& drawData, void* customData);
-ImVec2 menuBar(ApplicationData* appData);
-ImVec2 audioDeviceWindow(ApplicationData* appData, std::vector<AudioDevice>& deviceList, const char* title);
+#include <vector>
+#include <chrono>
+
+#define DAY_LINE_WIDTH 3.f
+#define DAY_LINE_OFFSET 5.f
+#define DAY_OUTLINE_SIZE 3.f
+
+typedef std::chrono::time_point<std::chrono::system_clock> TimePoint;
+
+void init(DrawData& drawData, ApplicationData& customData);
+void draw(DrawData& drawData, ApplicationData& customData);
+void cleanup(DrawData& drawData, ApplicationData& appData);
+
+ImVec2 menuBar(DrawData& drawData, ApplicationData& appData);
+ImVec2 checklistWindow(ApplicationData& appData, const char* title);
+ImVec2 timerWindow(DrawData& drawData, ApplicationData& appData);
+ImVec2 baseStationWindow(ApplicationData& appData);
+ImVec2 audioDeviceWindow(ApplicationData& appData, std::vector<AudioDevice>& deviceList, const char* title);
 void drawCircle(float radius, ImU32 color);

AsuroTool/AsuroTool.rc

@@ -64,6 +64,56 @@ LANGUAGE LANG_ENGLISH, SUBLANG_ENGLISH_UK
 // remains consistent on all systems.
 IDI_ICON1               ICON                    "kaiju.ico"
 
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// Version
+//
+
+VS_VERSION_INFO VERSIONINFO
+ FILEVERSION 1,0,4,1
+ PRODUCTVERSION 1,0,4,1
+ FILEFLAGSMASK 0x3fL
+#ifdef _DEBUG
+ FILEFLAGS 0x1L
+#else
+ FILEFLAGS 0x0L
+#endif
+ FILEOS 0x40004L
+ FILETYPE 0x1L
+ FILESUBTYPE 0x0L
+BEGIN
+    BLOCK "StringFileInfo"
+    BEGIN
+        BLOCK "200004b0"
+        BEGIN
+            VALUE "CompanyName", "Asuro"
+            VALUE "FileDescription", "Audio Thingy"
+            VALUE "FileVersion", "1.0.4.1"
+            VALUE "InternalName", "AsuroTool.exe"
+            VALUE "LegalCopyright", "Copyright (C) 2022"
+            VALUE "OriginalFilename", "AsuroTool.exe"
+            VALUE "ProductName", "Audio Thingy"
+            VALUE "ProductVersion", "1.0.4.1"
+        END
+    END
+    BLOCK "VarFileInfo"
+    BEGIN
+        VALUE "Translation", 0x2000, 1200
+    END
+END
+
+
+/////////////////////////////////////////////////////////////////////////////
+//
+// String Table
+//
+
+STRINGTABLE
+BEGIN
+    IDS_STRING_TOOLTIP      "Audio Thingy"
+END
+
 #endif    // English (United Kingdom) resources
 /////////////////////////////////////////////////////////////////////////////
 

AsuroTool/AsuroTool.vcxproj

@@ -80,11 +80,16 @@
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>E:\Code\AsuroImgui\ImguiBase;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);../ImguiBase</IncludePath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(VULKAN_SDK)/Lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>E:\Code\AsuroImgui\ImguiBase;$(VC_IncludePath);$(WindowsSDK_IncludePath);</IncludePath>
+    <IncludePath>$(VC_IncludePath);$(WindowsSDK_IncludePath);../ImguiBase</IncludePath>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(VULKAN_SDK)/Lib</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Label="Vcpkg">
+    <VcpkgEnableManifest>true</VcpkgEnableManifest>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -92,10 +97,15 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
+      <DisableSpecificWarnings>4305; 4244</DisableSpecificWarnings>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>pathcch.lib;runtimeobject.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -106,12 +116,17 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
+      <DisableSpecificWarnings>4305; 4244</DisableSpecificWarnings>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>pathcch.lib;runtimeobject.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -120,10 +135,15 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
+      <DisableSpecificWarnings>4305; 4244</DisableSpecificWarnings>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>pathcch.lib;runtimeobject.lib;vulkan-1.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Link>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -134,27 +154,42 @@
       <SDLCheck>true</SDLCheck>
       <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
       <ConformanceMode>true</ConformanceMode>
+      <DisableSpecificWarnings>4305; 4244</DisableSpecificWarnings>
+      <LanguageStandard>stdcpp20</LanguageStandard>
     </ClCompile>
     <Link>
       <SubSystem>Console</SubSystem>
       <EnableCOMDATFolding>true</EnableCOMDATFolding>
       <OptimizeReferences>true</OptimizeReferences>
       <GenerateDebugInformation>true</GenerateDebugInformation>
+      <AdditionalDependencies>pathcch.lib;runtimeobject.lib;vulkan-1.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Link>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="ApplicationData.cpp" />
     <ClCompile Include="AsuroTool.cpp" />
+    <ClCompile Include="AudioNotificationListener.cpp" />
+    <ClCompile Include="Settings.cpp" />
+    <ClCompile Include="Timer.cpp" />
     <ClCompile Include="Util.cpp" />
+    <ClCompile Include="WindowsShell.cpp" />
+    <ClCompile Include="WinToast\wintoastlib.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ApplicationData.h" />
     <ClInclude Include="AsuroTool.h" />
     <ClCompile Include="AudioApi.cpp" />
     <ClInclude Include="AudioApi.h" />
+    <ClInclude Include="AudioNotificationListener.h" />
     <ClInclude Include="PolicyConfig.h" />
     <ClInclude Include="resource.h" />
+    <ClInclude Include="Settings.h" />
+    <ClInclude Include="Timer.h" />
     <ClInclude Include="Util.h" />
+    <ClInclude Include="WindowsShell.h" />
+    <ClInclude Include="WinToast\wintoastlib.h" />
   </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\ImguiBase\ImguiBase.vcxproj">
@@ -189,12 +224,20 @@
     <ResourceCompile Include="AsuroTool.rc" />
   </ItemGroup>
   <ItemGroup>
-    <Image Include="d:\nextcloud\dragon collection\profile pics\icon2.ico" />
-    <Image Include="d:\nextcloud\dragon collection\profile pics\icon3.ico" />
-    <Image Include="D:\Nextcloud\Dragon Collection\Profile Pics\kaiju.ico" />
-    <Image Include="kaiju.ico" />
-    <Image Include="kaiju32.png" />
-    <Image Include="kaiju64.png" />
+    <CopyFileToFolders Include="kaiju.ico">
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">true</DeploymentContent>
+      <DeploymentContent Condition="'$(Configuration)|$(Platform)'=='Release|x64'">true</DeploymentContent>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <CopyFileToFolders Include="basestation\lighthouse-v2-manager.exe">
+      <FileType>Document</FileType>
+    </CopyFileToFolders>
+  </ItemGroup>
+  <ItemGroup>
+    <None Include="vcpkg.json" />
   </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">

AsuroTool/AsuroTool.vcxproj.filters

@@ -13,20 +13,47 @@
       <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
       <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
     </Filter>
+    <Filter Include="Source Files\Audio">
+      <UniqueIdentifier>{37b6f2f7-f9d0-428e-9a8f-4b034610a39a}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\Audio">
+      <UniqueIdentifier>{b65d213d-ddf6-4816-90d1-bf0811a51abf}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Source Files\lib">
+      <UniqueIdentifier>{7571e2e0-bbb5-4c09-a047-e1d3c2a0ed5e}</UniqueIdentifier>
+    </Filter>
+    <Filter Include="Header Files\lib">
+      <UniqueIdentifier>{ced4b7a2-267d-4b67-a8f1-41b3af68a5f0}</UniqueIdentifier>
+    </Filter>
   </ItemGroup>
   <ItemGroup>
     <ClCompile Include="AsuroTool.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="AudioApi.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
     <ClCompile Include="Util.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
     <ClCompile Include="ApplicationData.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
+    <ClCompile Include="AudioApi.cpp">
+      <Filter>Source Files\Audio</Filter>
+    </ClCompile>
+    <ClCompile Include="AudioNotificationListener.cpp">
+      <Filter>Source Files\Audio</Filter>
+    </ClCompile>
+    <ClCompile Include="Settings.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="WindowsShell.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
+    <ClCompile Include="WinToast\wintoastlib.cpp">
+      <Filter>Source Files\lib</Filter>
+    </ClCompile>
+    <ClCompile Include="Timer.cpp">
+      <Filter>Source Files</Filter>
+    </ClCompile>
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="AsuroTool.h">
@@ -35,18 +62,33 @@
     <ClInclude Include="Util.h">
       <Filter>Header Files</Filter>
     </ClInclude>
-    <ClInclude Include="PolicyConfig.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-    <ClInclude Include="AudioApi.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
     <ClInclude Include="ApplicationData.h">
       <Filter>Header Files</Filter>
     </ClInclude>
     <ClInclude Include="resource.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="AudioApi.h">
+      <Filter>Header Files\Audio</Filter>
+    </ClInclude>
+    <ClInclude Include="AudioNotificationListener.h">
+      <Filter>Header Files\Audio</Filter>
+    </ClInclude>
+    <ClInclude Include="Settings.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="PolicyConfig.h">
+      <Filter>Header Files\Audio</Filter>
+    </ClInclude>
+    <ClInclude Include="WindowsShell.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
+    <ClInclude Include="WinToast\wintoastlib.h">
+      <Filter>Header Files\lib</Filter>
+    </ClInclude>
+    <ClInclude Include="Timer.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <CopyFileToFolders Include="Montserrat-Regular.ttf">
@@ -55,6 +97,10 @@
     <CopyFileToFolders Include="remixicon.ttf">
       <Filter>Resource Files</Filter>
     </CopyFileToFolders>
+    <CopyFileToFolders Include="basestation\lighthouse-v2-manager.exe" />
+    <CopyFileToFolders Include="kaiju.ico">
+      <Filter>Resource Files</Filter>
+    </CopyFileToFolders>
   </ItemGroup>
   <ItemGroup>
     <ResourceCompile Include="AsuroTool.rc">
@@ -62,23 +108,6 @@
     </ResourceCompile>
   </ItemGroup>
   <ItemGroup>
-    <Image Include="d:\nextcloud\dragon collection\profile pics\icon2.ico">
-      <Filter>Resource Files</Filter>
-    </Image>
-    <Image Include="kaiju64.png">
-      <Filter>Resource Files</Filter>
-    </Image>
-    <Image Include="d:\nextcloud\dragon collection\profile pics\icon3.ico">
-      <Filter>Resource Files</Filter>
-    </Image>
-    <Image Include="D:\Nextcloud\Dragon Collection\Profile Pics\kaiju.ico">
-      <Filter>Resource Files</Filter>
-    </Image>
-    <Image Include="kaiju32.png">
-      <Filter>Resource Files</Filter>
-    </Image>
-    <Image Include="kaiju.ico">
-      <Filter>Resource Files</Filter>
-    </Image>
+    <None Include="vcpkg.json" />
   </ItemGroup>
 </Project>

AsuroTool/AudioApi.cpp

@@ -1,15 +1,119 @@
+#include "AudioApi.h"
+#include "Util.h"
+#include "PolicyConfig.h"
 
 #include <windows.h>
 #include <functiondiscoverykeys.h>
 #include <endpointvolume.h>
 
+#include <initguid.h>
+#include <mmdeviceapi.h>
+
+#include <array>
 #include <vector>
 #include <algorithm>
+#include <iostream>
 
-#include "ImguiBase.h"
-#include "Util.h"
-#include "AudioApi.h"
-#include "PolicyConfig.h"
+void initAudio(ApplicationData& appData)
+{
+	HRESULT audioResult = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&appData.audioData->deviceEnumerator));
+	isError(audioResult, "Failed to set up audio device enumerator: ");
+
+	appData.audioData->audioNotificationListener = new AudioNotificationListener(appData.audioData);
+	audioResult = appData.audioData->deviceEnumerator->RegisterEndpointNotificationCallback(appData.audioData->audioNotificationListener);
+	isError(audioResult, "Failed to register audio notification listener: ");
+
+	reloadDeviceLists(*appData.audioData);
+}
+
+void loadAudioDevices(AudioData& audioData, std::vector<AudioDevice>& deviceList, EDataFlow deviceType)
+{
+	deviceList.clear();
+
+	HRESULT err;
+	IMMDeviceCollection* deviceCollection = nullptr;
+
+	err = audioData.deviceEnumerator->EnumAudioEndpoints(deviceType, DEVICE_STATE_ACTIVE | DEVICE_STATE_DISABLED, &deviceCollection);
+	if (isError(err, "Failed to enumerate audio devices: ")) return;
+
+	UINT deviceCount;
+	err = deviceCollection->GetCount(&deviceCount);
+	if (isError(err, "Failed to count audio devices: ")) return;
+
+	IMMDevice* defaultConsoleDevice = nullptr;
+	LPWSTR defaultConsoleId = nullptr;
+	err = audioData.deviceEnumerator->GetDefaultAudioEndpoint(deviceType, ERole::eConsole, &defaultConsoleDevice);
+	if (!FAILED(err))
+	{
+		defaultConsoleDevice->GetId(&defaultConsoleId);
+	}
+
+	IMMDevice* defaultMediaOutput = nullptr;
+	LPWSTR defaultMediaId = nullptr;
+	err = audioData.deviceEnumerator->GetDefaultAudioEndpoint(deviceType, ERole::eMultimedia, &defaultMediaOutput);
+	if (!FAILED(err))
+	{
+		defaultMediaOutput->GetId(&defaultMediaId);
+	}
+
+	IMMDevice* defaultCommunicationOutput = nullptr;
+	LPWSTR defaultCommunicationId = nullptr;
+	err = audioData.deviceEnumerator->GetDefaultAudioEndpoint(deviceType, ERole::eCommunications, &defaultCommunicationOutput);
+	if (!FAILED(err))
+	{
+		defaultCommunicationOutput->GetId(&defaultCommunicationId);
+	}
+
+	for (UINT i = 0; i < deviceCount; i += 1)
+	{
+		IMMDevice* device;
+		err = deviceCollection->Item(i, &device);
+		if (isError(err, std::stringstream("Failed to get device ") << i << ": "))
+		{
+			continue;
+		}
+
+		LPWSTR deviceId;
+		err = device->GetId(&deviceId);
+		if (!isError(err, std::stringstream("Failed to get device id ") << i << ": "))
+		{
+			AudioDevice audioDevice(device, deviceId);
+
+			if (defaultConsoleId)
+			{
+				audioDevice.isDefaultConsole = wcscmp(defaultConsoleId, deviceId) == 0;
+			}
+			if (defaultMediaId)
+			{
+				audioDevice.isDefaultMedia = wcscmp(defaultMediaId, deviceId) == 0;
+			}
+			if (defaultCommunicationId)
+			{
+				audioDevice.isDefaultCommunication = wcscmp(defaultCommunicationId, deviceId) == 0;
+			}
+
+			if (audioDevice.isInitialized)
+			{
+				deviceList.push_back(std::move(audioDevice));
+			}
+		}
+
+		CoTaskMemFree(deviceId);
+	}
+
+	std::sort(deviceList.begin(), deviceList.end(), [](AudioDevice& a, AudioDevice& b) { return a.state < b.state; });
+
+	if (deviceCollection)
+	{
+		deviceCollection->Release();
+	}
+}
+
+void reloadDeviceLists(AudioData& audioData)
+{
+	loadAudioDevices(audioData, audioData.playbackDevices, EDataFlow::eRender);
+	loadAudioDevices(audioData, audioData.recordingDevices, EDataFlow::eCapture);
+}
 
 HRESULT getDeviceProperty(IPropertyStore* propertyStore, const PROPERTYKEY propertyKey, PROPVARIANT* outData)
 {
@@ -25,134 +129,24 @@ HRESULT getDevicePropertyString(IPropertyStore* propertyStore, const PROPERTYKEY
 	return result;
 }
 
-void setDefaultAudioDevice(ApplicationData* appData, const wchar_t* deviceId, ERole role)
+void setDefaultAudioDevice(AudioData& audioData, const wchar_t* deviceId, ERole role)
 {
-	IPolicyConfigVista* pPolicyConfig;
+	IPolicyConfigVista* pPolicyConfig = nullptr;
 
 	HRESULT hr = CoCreateInstance(__uuidof(CPolicyConfigVistaClient), NULL, CLSCTX_ALL, __uuidof(IPolicyConfigVista), (LPVOID*)&pPolicyConfig);
 	if (!isError(hr, "Failed to set default audio device: "))
 	{
 		hr = pPolicyConfig->SetDefaultEndpoint(deviceId, role);
 		pPolicyConfig->Release();
-		reloadDeviceLists(appData);
+		reloadDeviceLists(audioData);
 	}
 }
 
-void loadAudioDevices(std::vector<AudioDevice>& deviceList, EDataFlow deviceType)
-{
-	deviceList.clear();
-
-	HRESULT err;
-	IMMDeviceEnumerator* deviceEnumerator = NULL;
-	IMMDeviceCollection* deviceCollection = NULL;
-
-	err = CoCreateInstance(__uuidof(MMDeviceEnumerator), NULL, CLSCTX_INPROC_SERVER, IID_PPV_ARGS(&deviceEnumerator));
-	if (isError(err, "Failed to set up audio device enumerator: ")) return;
-
-	err = deviceEnumerator->EnumAudioEndpoints(deviceType, DEVICE_STATE_ACTIVE | DEVICE_STATE_DISABLED, &deviceCollection);
-	if (isError(err, "Failed to enumerate audio devices: ")) return;
-
-	UINT deviceCount;
-	err = deviceCollection->GetCount(&deviceCount);
-	if (isError(err, "Failed to count audio devices: ")) return;
-
-	IMMDevice* defaultConsoleDevice = NULL;
-	LPWSTR defaultConsoleId = nullptr;
-	err = deviceEnumerator->GetDefaultAudioEndpoint(deviceType, ERole::eConsole, &defaultConsoleDevice);
-	if (!FAILED(err))
-	{
-		defaultConsoleDevice->GetId(&defaultConsoleId);
-	}
-
-	IMMDevice* defaultMediaOutput = NULL;
-	LPWSTR defaultMediaId = nullptr;
-	err = deviceEnumerator->GetDefaultAudioEndpoint(deviceType, ERole::eMultimedia, &defaultMediaOutput);
-	if (!FAILED(err))
-	{
-		defaultMediaOutput->GetId(&defaultMediaId);
-	}
-
-	IMMDevice* defaultCommunicationOutput = NULL;
-	LPWSTR defaultCommunicationId = nullptr;
-	err = deviceEnumerator->GetDefaultAudioEndpoint(deviceType, ERole::eCommunications, &defaultCommunicationOutput);
-	if (!FAILED(err))
-	{
-		defaultCommunicationOutput->GetId(&defaultCommunicationId);
-	}
-
-	for (UINT i = 0; i < deviceCount; i += 1)
-	{
-		IMMDevice* device;
-		err = deviceCollection->Item(i, &device);
-		isError(err, std::stringstream("Failed to get device ") << i << ": ");
-
-		LPWSTR deviceId;
-		err = device->GetId(&deviceId);
-		isError(err, std::stringstream("Failed to get device id ") << i << ": ");
-
-		IPropertyStore* propertyStore;
-		err = device->OpenPropertyStore(STGM_READ, &propertyStore);
-		isError(err, std::stringstream("Failed to open device ") << i << "prop store: ");
-
-		PROPVARIANT deviceNameProp;
-		const wchar_t* deviceName;
-		err = getDevicePropertyString(propertyStore, PKEY_Device_FriendlyName, &deviceNameProp, deviceName);
-		isError(err, std::stringstream("Failed to read name of device ") << i << ": ");
-
-		DWORD deviceState;
-		err = device->GetState(&deviceState);
-		isError(err, std::stringstream("Failed to reat state of device ") << i << ": ");
-		
-		IAudioEndpointVolume* volumeInterface;
-		err = device->Activate(__uuidof(IAudioEndpointVolume), CLSCTX_INPROC_SERVER, NULL, (LPVOID*)&volumeInterface);
-		isError(err, "Failed to get audio endpoint volume interface: ");
-
-		IAudioMeterInformation* meterInterface;
-		err = device->Activate(__uuidof(IAudioMeterInformation), CLSCTX_INPROC_SERVER, NULL, (LPVOID*)&meterInterface);
-		isError(err, "Failed to get audio meter interface: ");
-
-		deviceList.push_back({
-			device,
-			volumeInterface,
-			meterInterface,
-			std::wstring(deviceId),
-			utf8Encode(deviceName),
-			deviceState,
-			utf8Encode(defaultConsoleId) == utf8Encode(deviceId),
-			utf8Encode(defaultMediaId) == utf8Encode(deviceId),
-			utf8Encode(defaultCommunicationId) == utf8Encode(deviceId),
-		});
-
-		// Free stuff
-		if (propertyStore)
-		{
-			propertyStore->Release();
-		}
-		CoTaskMemFree(deviceId);
-	}
-
-	if (deviceEnumerator)
-	{
-		deviceEnumerator->Release();
-	}
-	if (deviceCollection)
-	{
-		deviceCollection->Release();
-	}
-
-	std::sort(deviceList.begin(), deviceList.end(), [](AudioDevice& a, AudioDevice& b) { return a.state < b.state; });
-}
-
-void reloadDeviceLists(ApplicationData* appData)
-{
-	loadAudioDevices(appData->playbackDevices, EDataFlow::eRender);
-	loadAudioDevices(appData->recordingDevices, EDataFlow::eCapture);
-}
-
+// @slow (.2ms)
 float getVolume(IAudioEndpointVolume* volumeInterface)
 {
 	float volume;
-	if (FAILED(volumeInterface->GetChannelVolumeLevel(0, &volume)))
+	if (FAILED(volumeInterface->GetMasterVolumeLevelScalar(&volume)))
 	{
 		volume = 0.;
 	}
@@ -160,13 +154,93 @@ float getVolume(IAudioEndpointVolume* volumeInterface)
 	return volume;
 }
 
-float getMeterValue(IAudioMeterInformation* meterInterface)
+void setVolume(IAudioEndpointVolume* volumeInterface, float newVolume)
 {
-	float volume;
-	if (FAILED(meterInterface->GetPeakValue(&volume)))
-	{
-		volume = 0.;
-	}
-
-	return volume;
+	HRESULT hr = volumeInterface->SetMasterVolumeLevelScalar(newVolume, NULL);
+	isError(hr, "Failed to set volume level: ");
+}
+
+// @slow (.4ms)
+UINT getMeterValues(IAudioMeterInformation* meterInterface, std::array<float, 2>& outLevels)
+{
+	UINT channelCount;
+	if (FAILED(meterInterface->GetMeteringChannelCount(&channelCount)) || channelCount > 2) return 0;
+
+	if (FAILED(meterInterface->GetChannelsPeakValues(channelCount, &outLevels[0]))) return 0;
+
+	return channelCount;
+}
+
+void getVolumeLimit(IAudioEndpointVolume* volumeInterface, float* outMin, float* outMax)
+{
+	float dummy;
+	volumeInterface->GetVolumeRange(outMin, outMax, &dummy);
+}
+
+// @slow (.3ms)
+bool isMuted(IAudioEndpointVolume* volumeInterface)
+{
+	BOOL result = false;
+	if (FAILED(volumeInterface->GetMute(&result))) return false;
+
+	return static_cast<bool>(result);
+}
+
+void setMuted(IAudioEndpointVolume* volumeInterface, bool newState)
+{
+	volumeInterface->SetMute(static_cast<BOOL>(newState), NULL);
+}
+
+void CreateLoudnessEqualizationKey(PROPERTYKEY& key)
+{
+	// Realtek: const wchar_t* guid = L"E0A941A0-88A2-4df5-8D6B-DD20BB06E8FB";
+	const wchar_t* guid = L"FC52A749-4BE9-4510-896E-966BA6525980";
+	UuidFromString((RPC_WSTR)guid, &key.fmtid);
+	key.pid = 3;
+}
+
+AudioProcessingState getAudioProcessing(AudioDevice& device)
+{
+	return AudioProcessingState::Unknown;
+
+	LPWSTR pwstrEndpointId = NULL;
+	HRESULT hr = device.device->GetId(&pwstrEndpointId);
+
+	IPolicyConfig* pPolicyConfig;
+	hr = CoCreateInstance(__uuidof(CPolicyConfigClient), NULL, CLSCTX_ALL, IID_PPV_ARGS(&pPolicyConfig));
+	if (SUCCEEDED(hr))
+	{
+		PROPVARIANT var;
+		PropVariantInit(&var);
+
+		PROPERTYKEY key{};
+		CreateLoudnessEqualizationKey(key);
+
+		hr = pPolicyConfig->GetPropertyValue(pwstrEndpointId, TRUE, key, &var);
+		pPolicyConfig->Release();
+		return var.boolVal ? AudioProcessingState::Disabled : AudioProcessingState::Enabled;
+	}
+	return AudioProcessingState::Unknown;
+}
+
+void setAudioProcessing(AudioDevice& device, bool newVal)
+{
+	return;
+
+	LPWSTR pwstrEndpointId = NULL;
+	HRESULT hr = device.device->GetId(&pwstrEndpointId);
+
+	IPolicyConfig* pPolicyConfig;
+	hr = CoCreateInstance(__uuidof(CPolicyConfigClient), NULL, CLSCTX_ALL, IID_PPV_ARGS(&pPolicyConfig));
+	if (SUCCEEDED(hr))
+	{
+		PROPVARIANT var;
+		PropVariantInit(&var);
+		var.vt = VT_UI4;
+		var.uintVal = newVal ? ENDPOINT_SYSFX_ENABLED : ENDPOINT_SYSFX_DISABLED;
+		PROPERTYKEY key{};
+		CreateLoudnessEqualizationKey(key);
+		hr = pPolicyConfig->SetPropertyValue(pwstrEndpointId, TRUE, key, &var);
+		pPolicyConfig->Release();
+	}
 }

AsuroTool/AudioApi.h

@@ -1,13 +1,27 @@
 #pragma once
 
-#include <mmdeviceapi.h>
-
 #include "ApplicationData.h"
 
+enum class AudioProcessingState
+{
+	Enabled,
+	Disabled,
+	Unknown
+};
+
+void initAudio(ApplicationData& appData);
+void loadAudioDevices(AudioData& audioData, std::vector<AudioDevice>& deviceList, EDataFlow deviceType);
+void reloadDeviceLists(AudioData& audioData);
+
 HRESULT getDeviceProperty(IPropertyStore* propertyStore, const PROPERTYKEY propertyKey, PROPVARIANT* outData);
 HRESULT getDevicePropertyString(IPropertyStore* propertyStore, const PROPERTYKEY propertyKey, PROPVARIANT* outData, const wchar_t*& outString, const wchar_t* defaultStr = L"Unknown");
-void setDefaultAudioDevice(ApplicationData* appData, const wchar_t* deviceId, ERole role);
-void loadAudioDevices(std::vector<AudioDevice>& deviceList, EDataFlow deviceType);
-void reloadDeviceLists(ApplicationData* appData);
+void setDefaultAudioDevice(AudioData& audioData, const wchar_t* deviceId, ERole role);
+
 float getVolume(IAudioEndpointVolume* volumeInterface);
-float getMeterValue(IAudioMeterInformation* meterInterface);
+void setVolume(IAudioEndpointVolume* volumeInterface, float newVolume);
+UINT getMeterValues(IAudioMeterInformation* meterInterface, std::array<float, 2>& levels);
+void getVolumeLimit(IAudioEndpointVolume* volumeInterface, float* outMin, float* outMax);
+bool isMuted(IAudioEndpointVolume* volumeInterface);
+void setMuted(IAudioEndpointVolume* volumeInterface, bool newState);
+AudioProcessingState getAudioProcessing(AudioDevice& device);
+void setAudioProcessing(AudioDevice& device, bool newVal);

AsuroTool/AudioNotificationListener.cpp

@@ -0,0 +1,170 @@
+#include <windows.h>
+
+#include "AudioApi.h"
+#include "AudioNotificationListener.h"
+
+
+AudioNotificationListener::AudioNotificationListener(std::shared_ptr<AudioData> audioData) : audioData(audioData)
+{
+
+}
+
+HRESULT __stdcall AudioNotificationListener::OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState)
+{
+	auto updateDevice = [pwstrDeviceId, dwNewState](std::vector<AudioDevice>& deviceList)
+	{
+		for (auto& audioDevice : deviceList)
+		{
+			if (wcscmp(audioDevice.id.c_str(), pwstrDeviceId) == 0)
+			{
+				audioDevice.state = dwNewState;
+			}
+		}
+	};
+
+	updateDevice(audioData->playbackDevices);
+	updateDevice(audioData->recordingDevices);
+
+	return S_OK;
+}
+
+HRESULT __stdcall AudioNotificationListener::OnDeviceAdded(LPCWSTR pwstrDeviceId)
+{
+	IMMDevice* newDevice;
+	HRESULT result = audioData->deviceEnumerator->GetDevice(pwstrDeviceId, &newDevice);
+	if (SUCCEEDED(result) && newDevice != nullptr)
+	{
+		IMMEndpoint* endpoint;
+		result = newDevice->QueryInterface(&endpoint);
+		if (SUCCEEDED(result) && endpoint != nullptr)
+		{
+			EDataFlow dataFlow;
+			result = endpoint->GetDataFlow(&dataFlow);
+			if (SUCCEEDED(result))
+			{
+				AudioDevice audioDevice(newDevice, pwstrDeviceId);
+				if (dataFlow == EDataFlow::eCapture)
+				{
+					audioData->recordingDevices.push_back(std::move(audioDevice));
+				}
+				else
+				{
+					audioData->playbackDevices.push_back(std::move(audioDevice));
+				}
+			}
+		}
+	}
+
+	return result;
+}
+
+HRESULT __stdcall AudioNotificationListener::OnDeviceRemoved(LPCWSTR pwstrDeviceId)
+{
+	auto deleteDevice = [pwstrDeviceId](std::vector<AudioDevice>& deviceList)
+	{
+		auto deviceListIterator = deviceList.begin();
+		while (deviceListIterator != deviceList.end())
+		{
+			if (wcscmp(deviceListIterator->id.c_str(), pwstrDeviceId) == 0)
+			{
+				deviceListIterator = deviceList.erase(deviceListIterator);
+				continue;
+			}
+			deviceListIterator++;
+		}
+	};
+
+	deleteDevice(audioData->playbackDevices);
+	deleteDevice(audioData->recordingDevices);
+
+	return S_OK;
+}
+
+HRESULT __stdcall AudioNotificationListener::OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId)
+{
+	std::vector<AudioDevice>* deviceList;
+	if (flow == EDataFlow::eRender)
+	{
+		deviceList = &audioData->playbackDevices;
+	}
+	else
+	{
+		deviceList = &audioData->recordingDevices;
+	}
+
+	for (AudioDevice& audioDevice : *deviceList)
+	{
+		if (wcscmp(audioDevice.id.c_str(), pwstrDefaultDeviceId) == 0)
+		{
+			switch (role)
+			{
+			case ERole::eCommunications:
+				audioDevice.isDefaultCommunication = true;
+				break;
+			case ERole::eConsole:
+				audioDevice.isDefaultConsole = true;
+				break;
+			case ERole::eMultimedia:
+				audioDevice.isDefaultMedia = true;
+				break;
+			}
+		}
+		else
+		{
+			switch (role)
+			{
+			case ERole::eCommunications:
+				audioDevice.isDefaultCommunication = false;
+				break;
+			case ERole::eConsole:
+				audioDevice.isDefaultConsole = false;
+				break;
+			case ERole::eMultimedia:
+				audioDevice.isDefaultMedia = false;
+				break;
+			}
+		}
+	}
+
+	return S_OK;
+}
+
+HRESULT __stdcall AudioNotificationListener::OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key)
+{
+	return S_OK;
+}
+
+// Copy pasted stuff from Windows SDK Example
+// No clue what it does lol
+// https://github.com/pauldotknopf/WindowsSDK7-Samples/blob/master/multimedia/audio/osd/endpointMonitor.cpp
+HRESULT __stdcall AudioNotificationListener::QueryInterface(REFIID riid, void** ppvObject)
+{
+	if ((riid == __uuidof(IUnknown)) ||
+		(riid == __uuidof(IMMNotificationClient)))
+	{
+		*ppvObject = static_cast<IMMNotificationClient*>(this);
+	}
+	else
+	{
+		*ppvObject = nullptr;
+		return E_NOINTERFACE;
+	}
+
+	AddRef();
+	return S_OK;
+}
+
+ULONG __stdcall AudioNotificationListener::AddRef(void)
+{
+	return InterlockedIncrement(&refCount);
+}
+
+ULONG __stdcall AudioNotificationListener::Release(void)
+{
+	long refCountResult = InterlockedDecrement(&refCount);
+	if (refCountResult == 0)
+	{
+		delete this;
+	}
+	return refCountResult;
+}

AsuroTool/AudioNotificationListener.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <initguid.h>
+#include <mmdeviceapi.h>
+
+#include <memory>
+
+class AudioData;
+class ApplicationData;
+class AudioNotificationListener : public IMMNotificationClient {
+public:
+	std::shared_ptr<AudioData> audioData;
+	long refCount = 1;
+
+	AudioNotificationListener(std::shared_ptr<AudioData> audioData);
+
+	virtual HRESULT __stdcall OnDeviceStateChanged(LPCWSTR pwstrDeviceId, DWORD dwNewState) override;
+	virtual HRESULT __stdcall OnDeviceAdded(LPCWSTR pwstrDeviceId) override;
+	virtual HRESULT __stdcall OnDeviceRemoved(LPCWSTR pwstrDeviceId) override;
+	virtual HRESULT __stdcall OnDefaultDeviceChanged(EDataFlow flow, ERole role, LPCWSTR pwstrDefaultDeviceId) override;
+	virtual HRESULT __stdcall OnPropertyValueChanged(LPCWSTR pwstrDeviceId, const PROPERTYKEY key) override;
+
+	virtual HRESULT __stdcall QueryInterface(REFIID riid, void** ppvObject) override;
+	virtual ULONG __stdcall AddRef(void) override;
+	virtual ULONG __stdcall Release(void) override;
+};
+

AsuroTool/PolicyConfig.h

@@ -115,6 +115,9 @@ public:
         PCWSTR,
         INT
     );
+
+    virtual HRESULT STDMETHODCALLTYPE GetPropertyValue(PCWSTR pszDeviceName, BOOL bFxStore, const PROPERTYKEY& pKey, PROPVARIANT* pv) = 0;
+    virtual HRESULT STDMETHODCALLTYPE SetPropertyValue(PCWSTR pszDeviceName, BOOL bFxStore, const PROPERTYKEY& pKey, PROPVARIANT* pv) = 0;
 };
 
 interface DECLSPEC_UUID("568b9108-44bf-40b4-9006-86afe5b5a620") IPolicyConfigVista;

AsuroTool/Settings.cpp

@@ -0,0 +1,245 @@
+#include "ApplicationData.h"
+#include "ImguiBase.h"
+#include "Util.h"
+#include "Settings.h"
+
+#include <chrono>
+
+extern bool justDocked;
+extern DrawData* gDrawData;
+extern ApplicationData* gAppData;
+
+void initSettings(DrawData& drawData, ApplicationData& appData)
+{
+	ImGuiSettingsHandler ini_handler;
+	ini_handler.TypeName = APPLICATION_SETTINGS_GROUP;
+	ini_handler.TypeHash = ImHashStr(APPLICATION_SETTINGS_GROUP);
+	ini_handler.ReadOpenFn = settingsReadOpen;
+	ini_handler.ReadLineFn = settingsReadLine;
+	ini_handler.WriteAllFn = settingsWriteAll;
+	GImGui->SettingsHandlers.push_back(ini_handler);
+	ImGui::LoadIniSettingsFromDisk("imgui.ini");
+	applySettings(drawData, appData);
+}
+
+void* settingsReadOpen(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name)
+{
+	ApplicationSettings* settings = &gAppData->settings;
+	*settings = ApplicationSettings();
+	return (void*)settings;
+}
+
+void settingsReadLine(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line)
+{
+	if (strlen(line) == 0) return;
+
+	ApplicationSettings* settings = (ApplicationSettings*)entry;
+
+	int docked;
+	if (sscanf_s(line, "docked=%i", &docked))
+	{
+		settings->docked = (bool)docked;
+	}
+	
+	int autostart;
+	if (sscanf_s(line, "autostart=%i", &autostart))
+	{
+		settings->autostart = (bool)autostart;
+	}
+	
+	std::string taskName{};
+	taskName.resize(MAX_TASK_NAME_LENGTH);
+	if (sscanf_s(line, "taskname=%s", &taskName[0], MAX_TASK_NAME_LENGTH))
+	{
+		settings->taskNames.push_back(taskName);
+	}
+	
+	std::string task{};
+	task.resize(MAX_TASK_NAME_LENGTH);
+	int year;
+	unsigned int month;
+	unsigned int day;
+	if (sscanf_s(line, "task=%d-%u-%u %s", &year, &month, &day, &task[0], MAX_TASK_NAME_LENGTH))
+	{
+		std::chrono::year_month_day date = std::chrono::year_month_day{ std::chrono::year{year}, std::chrono::month{month}, std::chrono::day{day} };
+		if (settings->tasks.contains(task))
+		{
+			settings->tasks[task].push_back(date);
+		}
+		else
+		{
+			settings->tasks.insert({ task, std::vector{ date } });
+		}
+	}
+
+	std::string baseStationMac{};
+	baseStationMac.resize(MAX_MAC_ADDRESS_LENGTH);
+	if (sscanf_s(line, "baseStationMac=%s", &baseStationMac[0], MAX_MAC_ADDRESS_LENGTH))
+	{
+		settings->baseStationMacAdresses.push_back(baseStationMac);
+	}
+
+	// baseStationShowConsole
+	int baseStationShowConsole;
+	if (sscanf_s(line, "baseStationShowConsole=%i", &baseStationShowConsole))
+	{
+		settings->baseStationShowConsole = (bool)baseStationShowConsole;
+	}
+
+	float timerDuration;
+	if (sscanf_s(line, "timerDuration=%f", &timerDuration))
+	{
+		settings->timerDuration = timerDuration;
+	}
+	
+	float timerRepeatDuration;
+	if (sscanf_s(line, "timerRepeatDuration=%f", &timerRepeatDuration))
+	{
+		settings->timerRepeatDuration = timerRepeatDuration;
+	}
+
+	int timerRepeating;
+	if (sscanf_s(line, "timerRepeating=%i", &timerRepeating))
+	{
+		settings->timerRepeating = (bool)timerRepeating;
+	}
+}
+
+void settingsWriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* outBuf)
+{
+	outBuf->appendf("[%s][%s]\n", APPLICATION_SETTINGS_GROUP, APPLICATION_SETTINGS_GROUP);
+	outBuf->appendf("docked=%i\n", (int)gAppData->settings.docked);
+	outBuf->appendf("autostart=%i\n", (int)gAppData->settings.autostart);
+
+	for (std::string& taskName : gAppData->settings.taskNames)
+	{
+		outBuf->appendf("taskname=%s\n", taskName.c_str());
+	}
+
+	for (auto& task : gAppData->settings.tasks)
+	{
+		for (auto& date : task.second)
+		{
+			outBuf->appendf("task=%d-%u-%u %s\n", int{ date.year() }, unsigned int{ date.month() }, unsigned int{ date.day() }, task.first.c_str());
+		}
+	}
+
+	for (std::string& baseStationMac : gAppData->settings.baseStationMacAdresses)
+	{
+		outBuf->appendf("baseStationMac=%s\n", baseStationMac.c_str());
+	}
+
+	outBuf->appendf("timerDuration=%f\n", gAppData->settings.timerDuration);
+	outBuf->appendf("timerRepeatDuration=%f\n", gAppData->settings.timerRepeatDuration);
+	outBuf->appendf("timerRepeating=%i\n", (int)gAppData->settings.timerRepeating);
+}
+
+void applySettings(DrawData& drawData, ApplicationData& appData)
+{
+	updateDocked(drawData, appData);
+	setAutostart(appData.settings.autostart);
+}
+
+void updateDocked(DrawData& drawData, ApplicationData& appData)
+{
+	justDocked = true;
+
+	glfwSetWindowAttrib(drawData.window, GLFW_DECORATED, !appData.settings.docked);
+	ShowWindow(drawData.window_handle, SW_HIDE);
+	SetWindowLongPtr(drawData.window_handle, GWL_EXSTYLE, appData.settings.docked ? WS_EX_TOOLWINDOW : 0);
+	ShowWindow(drawData.window_handle, SW_SHOW);
+}
+
+void setAutostart(bool newValue)
+{
+	const size_t MAX_PATH_LENGTH = 2048;
+	const wchar_t* KEY_APP_NAME = L"AsuroTool";
+
+	HRESULT hr;
+
+	HKEY runKey = nullptr;
+	hr = RegCreateKey(HKEY_CURRENT_USER, L"SOFTWARE\\Microsoft\\Windows\\CurrentVersion\\Run", &runKey);
+	if (isError(hr, "Failed to find/create autostart run key: ")) return;
+
+	if (newValue)
+	{
+		std::wstring appPath;
+		if (FAILED(getAppPath(appPath))) return;
+
+		hr = RegSetValueEx(runKey, KEY_APP_NAME, 0, REG_SZ, (BYTE*)appPath.c_str(), static_cast<DWORD>((appPath.size() + 1) * sizeof(wchar_t)));
+		if (isError(hr, "Failed to write autostart key: ")) return;
+	}
+	else
+	{
+		hr = RegDeleteValue(runKey, KEY_APP_NAME);
+		if (isError(hr, "Failed to delete autostart key: ")) return;
+	}
+}
+
+void loadUiStyle()
+{
+	ImGuiStyle& style = ImGui::GetStyle();
+	style.WindowPadding = { 10.f, 14.f };
+	style.WindowBorderSize = 0.f;
+
+	style.FramePadding = { 8.f, 4.f };
+
+	style.ItemSpacing = { 6.f, 4.f };
+	style.GrabRounding = 2.f;
+	style.PopupBorderSize = 4.f;
+
+	ImVec4* colors = style.Colors;
+	colors[ImGuiCol_Text] = ImVec4(1.00f, 1.00f, 1.00f, 1.00f);
+	colors[ImGuiCol_TextDisabled] = ImVec4(0.50f, 0.50f, 0.50f, 1.00f);
+	colors[ImGuiCol_WindowBg] = ImVec4(0.10f, 0.07f, 0.09f, 0.99f);
+	colors[ImGuiCol_ChildBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
+	colors[ImGuiCol_PopupBg] = ImVec4(0.08f, 0.04f, 0.07f, 1.00f);
+	colors[ImGuiCol_Border] = ImVec4(0.14f, 0.10f, 0.13f, 0.99f);
+	colors[ImGuiCol_BorderShadow] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
+	colors[ImGuiCol_FrameBg] = ImVec4(0.02f, 0.01f, 0.01f, 0.54f);
+	colors[ImGuiCol_FrameBgHovered] = ImVec4(0.98f, 0.36f, 0.36f, 0.40f);
+	colors[ImGuiCol_FrameBgActive] = ImVec4(0.60f, 0.41f, 0.41f, 0.67f);
+	colors[ImGuiCol_TitleBg] = ImVec4(0.04f, 0.04f, 0.04f, 1.00f);
+	colors[ImGuiCol_TitleBgActive] = ImVec4(0.48f, 0.16f, 0.16f, 1.00f);
+	colors[ImGuiCol_TitleBgCollapsed] = ImVec4(0.02f, 0.02f, 0.02f, 0.51f);
+	colors[ImGuiCol_MenuBarBg] = ImVec4(0.06f, 0.05f, 0.06f, 0.99f);
+	colors[ImGuiCol_ScrollbarBg] = ImVec4(0.02f, 0.02f, 0.02f, 0.53f);
+	colors[ImGuiCol_ScrollbarGrab] = ImVec4(0.31f, 0.31f, 0.31f, 1.00f);
+	colors[ImGuiCol_ScrollbarGrabHovered] = ImVec4(0.41f, 0.41f, 0.41f, 1.00f);
+	colors[ImGuiCol_ScrollbarGrabActive] = ImVec4(0.51f, 0.51f, 0.51f, 1.00f);
+	colors[ImGuiCol_CheckMark] = ImVec4(0.98f, 0.61f, 0.26f, 1.00f);
+	colors[ImGuiCol_SliderGrab] = ImVec4(0.88f, 0.38f, 0.24f, 1.00f);
+	colors[ImGuiCol_SliderGrabActive] = ImVec4(0.98f, 0.41f, 0.26f, 1.00f);
+	colors[ImGuiCol_Button] = ImVec4(0.21f, 0.11f, 0.17f, 1.00f);
+	colors[ImGuiCol_ButtonHovered] = ImVec4(0.30f, 0.15f, 0.25f, 1.00f);
+	colors[ImGuiCol_ButtonActive] = ImVec4(0.47f, 0.23f, 0.39f, 1.00f);
+	colors[ImGuiCol_Header] = ImVec4(0.46f, 0.19f, 0.12f, 0.67f);
+	colors[ImGuiCol_HeaderHovered] = ImVec4(0.69f, 0.29f, 0.19f, 0.80f);
+	colors[ImGuiCol_HeaderActive] = ImVec4(0.98f, 0.41f, 0.26f, 1.00f);
+	colors[ImGuiCol_Separator] = ImVec4(0.50f, 0.45f, 0.43f, 0.50f);
+	colors[ImGuiCol_SeparatorHovered] = ImVec4(0.75f, 0.24f, 0.10f, 0.78f);
+	colors[ImGuiCol_SeparatorActive] = ImVec4(0.75f, 0.24f, 0.10f, 1.00f);
+	colors[ImGuiCol_ResizeGrip] = ImVec4(0.98f, 0.41f, 0.26f, 0.20f);
+	colors[ImGuiCol_ResizeGripHovered] = ImVec4(0.98f, 0.41f, 0.26f, 0.67f);
+	colors[ImGuiCol_ResizeGripActive] = ImVec4(0.98f, 0.41f, 0.26f, 0.95f);
+	colors[ImGuiCol_Tab] = ImVec4(0.09f, 0.02f, 0.07f, 0.86f);
+	colors[ImGuiCol_TabHovered] = ImVec4(0.28f, 0.15f, 0.24f, 1.00f);
+	colors[ImGuiCol_TabActive] = ImVec4(0.37f, 0.14f, 0.29f, 1.00f);
+	colors[ImGuiCol_TabUnfocused] = ImVec4(0.33f, 0.21f, 0.28f, 1.00f);
+	colors[ImGuiCol_TabUnfocusedActive] = ImVec4(0.42f, 0.20f, 0.14f, 1.00f);
+	colors[ImGuiCol_PlotLines] = ImVec4(0.61f, 0.61f, 0.61f, 1.00f);
+	colors[ImGuiCol_PlotLinesHovered] = ImVec4(1.00f, 0.43f, 0.35f, 1.00f);
+	colors[ImGuiCol_PlotHistogram] = ImVec4(0.90f, 0.70f, 0.00f, 1.00f);
+	colors[ImGuiCol_PlotHistogramHovered] = ImVec4(1.00f, 0.60f, 0.00f, 1.00f);
+	colors[ImGuiCol_TableHeaderBg] = ImVec4(0.25f, 0.10f, 0.10f, 1.00f);
+	colors[ImGuiCol_TableBorderStrong] = ImVec4(0.31f, 0.31f, 0.35f, 1.00f);
+	colors[ImGuiCol_TableBorderLight] = ImVec4(0.23f, 0.23f, 0.25f, 1.00f);
+	colors[ImGuiCol_TableRowBg] = ImVec4(0.00f, 0.00f, 0.00f, 0.00f);
+	colors[ImGuiCol_TableRowBgAlt] = ImVec4(1.00f, 1.00f, 1.00f, 0.06f);
+	colors[ImGuiCol_TextSelectedBg] = ImVec4(0.26f, 0.59f, 0.98f, 0.35f);
+	colors[ImGuiCol_DragDropTarget] = ImVec4(1.00f, 1.00f, 0.00f, 0.90f);
+	colors[ImGuiCol_NavHighlight] = ImVec4(0.26f, 0.59f, 0.98f, 1.00f);
+	colors[ImGuiCol_NavWindowingHighlight] = ImVec4(1.00f, 1.00f, 1.00f, 0.70f);
+	colors[ImGuiCol_NavWindowingDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.20f);
+	colors[ImGuiCol_ModalWindowDimBg] = ImVec4(0.80f, 0.80f, 0.80f, 0.35f);
+}

AsuroTool/Settings.h

@@ -0,0 +1,21 @@
+#pragma once
+#include "ApplicationData.h"
+#include "ImguiBase.h"
+
+#include <imgui_internal.h>
+
+#define APPLICATION_SETTINGS_GROUP "ApplicationSettings"
+#define MAX_TASK_NAME_LENGTH 1024
+#define MAX_MAC_ADDRESS_LENGTH 128
+
+void initSettings(DrawData& drawData, ApplicationData& appData);
+
+void* settingsReadOpen(ImGuiContext* ctx, ImGuiSettingsHandler* handler, const char* name);
+void settingsReadLine(ImGuiContext* ctx, ImGuiSettingsHandler* handler, void* entry, const char* line);
+void settingsWriteAll(ImGuiContext* ctx, ImGuiSettingsHandler* handler, ImGuiTextBuffer* outBuf);
+
+void applySettings(DrawData& drawData, ApplicationData& appData);
+void updateDocked(DrawData& drawData, ApplicationData& appData);
+void setAutostart(bool newValue);
+
+void loadUiStyle();

AsuroTool/Timer.cpp

@@ -0,0 +1,65 @@
+#include "Timer.h"
+
+
+float calcElapsedSeconds(std::chrono::system_clock::time_point startTime)
+{
+	auto elapsedTime = std::chrono::system_clock::now() - startTime;
+	return std::chrono::duration_cast<std::chrono::seconds>(elapsedTime).count();
+}
+
+void updateTimer(ApplicationData& appData)
+{
+	while (true)
+	{
+		appData.timerMutex.lock();
+		TimerData& timerData = appData.timerData;
+
+		if (timerData.isTimerActive)
+		{
+			// Main timer
+			float elapsedSeconds = calcElapsedSeconds(timerData.timerStartTimestamp);
+			float timerPercentComplete = elapsedSeconds / appData.settings.timerDuration;
+
+			if (timerPercentComplete >= 1.f)
+			{
+				if (!timerData.timerHasNotified)
+				{
+					// Alert
+					timerData.timerHasNotified = true;
+
+					std::wstring titleText = std::format(L"{} minutes over!", appData.settings.timerDuration / 60.f);
+
+					std::wstring messageText;
+					if (appData.settings.timerRepeating)
+					{
+						messageText = std::format(L"Repeats every {} minutes.", appData.settings.timerRepeatDuration / 60.f);
+						timerData.lastNotifySeconds = elapsedSeconds;
+					}
+					else
+					{
+						timerData.isTimerActive = false;
+						messageText = L"Timer does not repeat.";
+					}
+					showToastNotification(&timerData.toastHandler, titleText.c_str(), messageText.c_str(), appData.settings.timerRepeating ? appData.settings.timerRepeatDuration * 1000 : 0);
+				}
+				else
+				{
+					// Loop timer
+					if (elapsedSeconds - timerData.lastNotifySeconds >= appData.settings.timerRepeatDuration)
+					{
+						timerData.lastNotifySeconds = elapsedSeconds;
+
+						float elapsedSecondsSinceEnd = elapsedSeconds - appData.settings.timerDuration;
+						std::wstring titleText = std::format(L"Timer ended {} minutes ago", elapsedSecondsSinceEnd / 60.f);
+						std::wstring messageText = std::format(L"Repeats every {} minutes.", appData.settings.timerRepeatDuration / 60.f);
+
+						showToastNotification(&timerData.toastHandler, titleText.c_str(), messageText.c_str());
+					}
+				}
+			}
+		}
+
+		appData.timerMutex.unlock();
+		Sleep(1000);
+	}
+}

AsuroTool/Timer.h

@@ -0,0 +1,8 @@
+#pragma once
+
+#include <chrono>
+
+#include "ApplicationData.h"
+
+float calcElapsedSeconds(std::chrono::system_clock::time_point startTime);
+void updateTimer(ApplicationData& appData);

AsuroTool/Util.cpp

@@ -1,6 +1,7 @@
 #include <iostream>
 
 #include "Util.h"
+#include "pathcch.h"
 
 bool isError(const HRESULT result, const std::stringstream message)
 {
@@ -29,3 +30,24 @@ std::string utf8Encode(const std::wstring& wstr)
 	WideCharToMultiByte(CP_UTF8, 0, wstr.c_str(), -1, &resultString[0], sizeNeeded, NULL, NULL);
 	return resultString;
 }
+
+HRESULT getAppPath(std::wstring& outPath)
+{
+	const size_t MAX_PATH_LENGTH = 32767;
+	outPath.resize(MAX_PATH_LENGTH);
+	HRESULT hr = GetModuleFileName(NULL, &outPath[0], static_cast<DWORD>(outPath.size()));
+	if (isError(hr, "Failed to get executable name: ")) return hr;
+	outPath.resize(wcslen(outPath.data()));
+	return hr;
+}
+
+HRESULT getAppDir(std::wstring& outPath)
+{
+	HRESULT hr = getAppPath(outPath);
+	if (FAILED(hr)) return hr;
+
+	hr = PathCchRemoveFileSpec(&outPath[0], static_cast<DWORD>(outPath.size()));
+	if (isError(hr, "Failed to get executable dir: ")) return hr;
+	outPath.resize(wcslen(outPath.data()));
+	return hr;
+}

AsuroTool/Util.h

@@ -1,8 +1,11 @@
 #pragma once
 
 #include <windows.h>
+
 #include <sstream>
 
 bool isError(const HRESULT result, const std::stringstream message);
 bool isError(const HRESULT result, const char* message);
 std::string utf8Encode(const std::wstring& wstr);
+HRESULT getAppPath(std::wstring& outPath);
+HRESULT getAppDir(std::wstring& outPath);

AsuroTool/WinToast/wintoastlib.h

@@ -0,0 +1,234 @@
+/* * Copyright (C) 2016-2019 Mohammed Boujemaoui <mohabouje@gmail.com>
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy of
+ * this software and associated documentation files (the "Software"), to deal in
+ * the Software without restriction, including without limitation the rights to
+ * use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+ * the Software, and to permit persons to whom the Software is furnished to do so,
+ * subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+ * FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+ * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+ * IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+ * CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef WINTOASTLIB_H
+#define WINTOASTLIB_H
+#include <Windows.h>
+#include <sdkddkver.h>
+#include <WinUser.h>
+#include <ShObjIdl.h>
+#include <wrl/implements.h>
+#include <wrl/event.h>
+#include <windows.ui.notifications.h>
+#include <strsafe.h>
+#include <Psapi.h>
+#include <ShlObj.h>
+#include <roapi.h>
+#include <propvarutil.h>
+#include <functiondiscoverykeys.h>
+#include <iostream>
+#include <winstring.h>
+#include <string.h>
+#include <vector>
+#include <map>
+using namespace Microsoft::WRL;
+using namespace ABI::Windows::Data::Xml::Dom;
+using namespace ABI::Windows::Foundation;
+using namespace ABI::Windows::UI::Notifications;
+using namespace Windows::Foundation;
+
+
+namespace WinToastLib {
+
+    class IWinToastHandler {
+    public:
+        enum WinToastDismissalReason {
+            UserCanceled = ToastDismissalReason::ToastDismissalReason_UserCanceled,
+            ApplicationHidden = ToastDismissalReason::ToastDismissalReason_ApplicationHidden,
+            TimedOut = ToastDismissalReason::ToastDismissalReason_TimedOut
+        };
+        virtual ~IWinToastHandler() = default;
+        virtual void toastActivated() const = 0;
+        virtual void toastActivated(int actionIndex) const = 0;
+        virtual void toastDismissed(WinToastDismissalReason state) const = 0;
+        virtual void toastFailed() const = 0;
+    };
+
+    class WinToastTemplate {
+    public:
+        enum class Scenario { Default, Alarm, IncomingCall, Reminder };
+        enum Duration { System, Short, Long };
+        enum AudioOption { Default = 0, Silent, Loop };
+        enum TextField { FirstLine = 0, SecondLine, ThirdLine };
+        enum WinToastTemplateType {
+            ImageAndText01 = ToastTemplateType::ToastTemplateType_ToastImageAndText01,
+            ImageAndText02 = ToastTemplateType::ToastTemplateType_ToastImageAndText02,
+            ImageAndText03 = ToastTemplateType::ToastTemplateType_ToastImageAndText03,
+            ImageAndText04 = ToastTemplateType::ToastTemplateType_ToastImageAndText04,
+            Text01 = ToastTemplateType::ToastTemplateType_ToastText01,
+            Text02 = ToastTemplateType::ToastTemplateType_ToastText02,
+            Text03 = ToastTemplateType::ToastTemplateType_ToastText03,
+            Text04 = ToastTemplateType::ToastTemplateType_ToastText04,
+        };
+
+        enum AudioSystemFile {
+            DefaultSound,
+            IM,
+            Mail,
+            Reminder,
+            SMS,
+            Alarm,
+            Alarm2,
+            Alarm3,
+            Alarm4,
+            Alarm5,
+            Alarm6,
+            Alarm7,
+            Alarm8,
+            Alarm9,
+            Alarm10,
+            Call,
+            Call1,
+            Call2,
+            Call3,
+            Call4,
+            Call5,
+            Call6,
+            Call7,
+            Call8,
+            Call9,
+            Call10,
+        };
+
+
+        WinToastTemplate(_In_ WinToastTemplateType type = WinToastTemplateType::ImageAndText02);
+        ~WinToastTemplate();
+
+        void setFirstLine(_In_ const std::wstring& text);
+        void setSecondLine(_In_ const std::wstring& text);
+        void setThirdLine(_In_ const std::wstring& text);
+        void setTextField(_In_ const std::wstring& txt, _In_ TextField pos);
+        void setAttributionText(_In_ const std::wstring& attributionText);
+        void setImagePath(_In_ const std::wstring& imgPath);
+        void setAudioPath(_In_ WinToastTemplate::AudioSystemFile audio);
+        void setAudioPath(_In_ const std::wstring& audioPath);
+        void setAudioOption(_In_ WinToastTemplate::AudioOption audioOption);
+        void setDuration(_In_ Duration duration);
+        void setExpiration(_In_ INT64 millisecondsFromNow);
+        void setScenario(_In_ Scenario scenario);
+        void addAction(_In_ const std::wstring& label);
+
+        std::size_t textFieldsCount() const;
+        std::size_t actionsCount() const;
+        bool hasImage() const;
+        const std::vector<std::wstring>& textFields() const;
+        const std::wstring& textField(_In_ TextField pos) const;
+        const std::wstring& actionLabel(_In_ std::size_t pos) const;
+        const std::wstring& imagePath() const;
+        const std::wstring& audioPath() const;
+        const std::wstring& attributionText() const;
+        const std::wstring& scenario() const;
+        INT64 expiration() const;
+        WinToastTemplateType type() const;
+        WinToastTemplate::AudioOption audioOption() const;
+        Duration duration() const;
+    private:
+        std::vector<std::wstring>           _textFields{};
+        std::vector<std::wstring>           _actions{};
+        std::wstring                        _imagePath{};
+        std::wstring                        _audioPath{};
+        std::wstring                        _attributionText{};
+        std::wstring                        _scenario{L"Default"};
+        INT64                               _expiration{0};
+        AudioOption                         _audioOption{WinToastTemplate::AudioOption::Default};
+        WinToastTemplateType                _type{WinToastTemplateType::Text01};
+        Duration                            _duration{Duration::System};
+    };
+
+    class WinToast {
+    public:
+        enum WinToastError {
+            NoError = 0,
+            NotInitialized,
+            SystemNotSupported,
+            ShellLinkNotCreated,
+            InvalidAppUserModelID,
+            InvalidParameters,
+            InvalidHandler,
+            NotDisplayed,
+            UnknownError
+        };
+
+        enum ShortcutResult {
+            SHORTCUT_UNCHANGED = 0,
+            SHORTCUT_WAS_CHANGED = 1,
+            SHORTCUT_WAS_CREATED = 2,
+
+            SHORTCUT_MISSING_PARAMETERS = -1,
+            SHORTCUT_INCOMPATIBLE_OS = -2,
+            SHORTCUT_COM_INIT_FAILURE = -3,
+            SHORTCUT_CREATE_FAILED = -4
+        };
+
+        enum ShortcutPolicy {
+            /* Don't check, create, or modify a shortcut. */
+            SHORTCUT_POLICY_IGNORE = 0,
+            /* Require a shortcut with matching AUMI, don't create or modify an existing one. */
+            SHORTCUT_POLICY_REQUIRE_NO_CREATE = 1,
+            /* Require a shortcut with matching AUMI, create if missing, modify if not matching.
+             * This is the default. */
+            SHORTCUT_POLICY_REQUIRE_CREATE = 2,
+        };
+
+        WinToast(void);
+        virtual ~WinToast();
+        static WinToast* instance();
+        static bool isCompatible();
+        static bool isSupportingModernFeatures();
+        static std::wstring configureAUMI(_In_ const std::wstring& companyName,
+                                          _In_ const std::wstring& productName,
+                                          _In_ const std::wstring& subProduct = std::wstring(),
+                                          _In_ const std::wstring& versionInformation = std::wstring());
+        static const std::wstring& strerror(_In_ WinToastError error);
+        virtual bool initialize(_Out_opt_ WinToastError* error = nullptr);
+        virtual bool isInitialized() const;
+        virtual bool hideToast(_In_ INT64 id);
+        virtual INT64 showToast(_In_ const WinToastTemplate& toast, _In_ IWinToastHandler* handler, _Out_opt_ WinToastError* error = nullptr);
+        virtual void clear();
+        virtual enum ShortcutResult createShortcut();
+
+        const std::wstring& appName() const;
+        const std::wstring& appUserModelId() const;
+        void setAppUserModelId(_In_ const std::wstring& aumi);
+        void setAppName(_In_ const std::wstring& appName);
+        void setShortcutPolicy(_In_ ShortcutPolicy policy);
+
+    protected:
+        bool                                            _isInitialized{false};
+        bool                                            _hasCoInitialized{false};
+        ShortcutPolicy                                  _shortcutPolicy{SHORTCUT_POLICY_REQUIRE_CREATE};
+        std::wstring                                    _appName{};
+        std::wstring                                    _aumi{};
+        std::map<INT64, ComPtr<IToastNotification>>     _buffer{};
+
+        HRESULT validateShellLinkHelper(_Out_ bool& wasChanged);
+        HRESULT createShellLinkHelper();
+        HRESULT setImageFieldHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& path);
+        HRESULT setAudioFieldHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& path, _In_opt_ WinToastTemplate::AudioOption option = WinToastTemplate::AudioOption::Default);
+        HRESULT setTextFieldHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& text, _In_ UINT32 pos);
+        HRESULT setAttributionTextFieldHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& text);
+        HRESULT addActionHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& action, _In_ const std::wstring& arguments);
+        HRESULT addDurationHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& duration);
+        HRESULT addScenarioHelper(_In_ IXmlDocument *xml, _In_ const std::wstring& scenario);
+        ComPtr<IToastNotifier> notifier(_In_ bool* succeded) const;
+        void setError(_Out_opt_ WinToastError* error, _In_ WinToastError value);
+    };
+}
+#endif // WINTOASTLIB_H

AsuroTool/WindowsShell.cpp

@@ -0,0 +1,160 @@
+#include "WindowsShell.h"
+#include "resource.h"
+#include "ApplicationData.h"
+#include "Util.h"
+
+#define WIN32_LEAN_AND_MEAN
+#include <Windows.h>
+#include <shellapi.h>
+#include <commctrl.h>
+#include <strsafe.h>
+
+#include <iostream>
+
+const UINT TRAY_ID = 420;
+const UINT WMAPP_NOTIFYCALLBACK = WM_APP + 1;
+
+extern DrawData* gDrawData;
+extern ApplicationData* gAppData;
+extern bool justDocked;
+extern bool isHidden;
+
+void initShell(DrawData& drawData)
+{
+	// Set window icon
+	HINSTANCE instance = GetModuleHandle(NULL);
+	LPWSTR iconId = MAKEINTRESOURCE(IDI_ICON1);
+	HANDLE iconLarge = LoadImageW(instance, iconId, IMAGE_ICON, 64, 64, 0);
+	HANDLE iconSmall = LoadImageW(instance, iconId, IMAGE_ICON, 32, 32, 0);
+	SendMessage(drawData.window_handle, WM_SETICON, ICON_BIG, (LPARAM)iconLarge);
+	SendMessage(drawData.window_handle, WM_SETICON, ICON_SMALL, (LPARAM)iconSmall);
+	SendMessage(drawData.window_handle, WM_SETICON, ICON_SMALL2, (LPARAM)iconSmall);
+
+	// Set tray icon
+	NOTIFYICONDATA nid = { sizeof(nid) };
+	nid.hWnd = drawData.window_handle;
+	nid.uFlags = NIF_ICON | NIF_TIP | NIF_MESSAGE | NIF_SHOWTIP;
+	nid.uID = TRAY_ID;
+	nid.uCallbackMessage = WMAPP_NOTIFYCALLBACK;
+
+	HRESULT iconResult;
+	iconResult = LoadIconMetric(instance, iconId, LIM_SMALL, &nid.hIcon);
+	isError(iconResult, "Failed to load tray icon image: ");
+
+	iconResult = LoadString(instance, IDS_STRING_TOOLTIP, nid.szTip, ARRAYSIZE(nid.szTip));
+	isError(iconResult, "Failed to load tray icon text: ");
+
+	Shell_NotifyIcon(NIM_ADD, &nid);
+
+	nid.uVersion = NOTIFYICON_VERSION_4;
+	Shell_NotifyIcon(NIM_SETVERSION, &nid);
+
+	if (!SetWindowsHookEx(WH_CALLWNDPROC, trayIconEventHandler, instance, GetCurrentThreadId()))
+	{
+		std::cout << "Failed to hook tray icon events: " << std::hex << GetLastError() << std::endl;
+	}
+
+	// Setup Toasts
+	if (!WinToast::isCompatible()) {
+		OutputDebugString(L"Error, your system in not supported!\n");
+	}
+	WinToast::instance()->setAppName(L"AudioThingy");
+	const auto aumi = WinToast::configureAUMI(L"asuro", L"audiothingy");
+	WinToast::instance()->setAppUserModelId(aumi);
+	if (!WinToast::instance()->initialize()) {
+		OutputDebugString(L"Error, could not initialize the lib!\n");
+	}
+	
+	// Set window minimize behavior
+	glfwSetWindowIconifyCallback(drawData.window, [](GLFWwindow* window, int isIconified) {
+		if (isIconified && gAppData->settings.docked)
+		{
+			glfwHideWindow(window);
+		}
+		isHidden = isIconified;
+		});
+
+	glfwSetWindowFocusCallback(drawData.window, [](GLFWwindow* window, int isFocused) {
+		if (!isFocused && gAppData->settings.docked && !justDocked)
+		{
+			glfwIconifyWindow(window);
+		}
+		});
+}
+
+void showToastNotification(TimerToastHandler* handler, const wchar_t* title, const wchar_t* text, UINT64 expiresInMs)
+{
+	WinToastTemplate templ = WinToastTemplate(WinToastTemplate::ImageAndText01);
+	templ.setScenario(WinToastTemplate::Scenario::Alarm);
+	templ.setImagePath(L"E:\\Code\\AsuroImgui\\x64\\Debug\\kaiju.ico");
+	templ.setTextField(title, WinToastTemplate::FirstLine);
+	templ.setAttributionText(text);
+	templ.addAction(L"Stop");
+	templ.addAction(L"Dismiss");
+	if (expiresInMs > 0)
+	{
+		templ.setExpiration(expiresInMs);
+	}
+
+	if (!WinToast::instance()->showToast(templ, handler))
+	{
+		OutputDebugString(L"Error: Could not launch toast!\n");
+	}
+}
+
+void cleanupShell(DrawData& drawData)
+{
+	// Remove tray icon
+	NOTIFYICONDATA nid = { sizeof(nid) };
+	nid.hWnd = drawData.window_handle;
+	nid.uID = TRAY_ID;
+	Shell_NotifyIcon(NIM_DELETE, &nid);
+}
+
+LRESULT CALLBACK trayIconEventHandler(int code, WPARAM wParam, LPARAM lParam)
+{
+	if (code >= 0)
+	{
+		CWPSTRUCT* data = (CWPSTRUCT*)lParam;
+
+		if (data->message == WMAPP_NOTIFYCALLBACK)
+		{
+			auto id = HIWORD(data->lParam);
+			auto trayEvent = LOWORD(data->lParam);
+
+			if (id == TRAY_ID && (trayEvent == WM_LBUTTONUP || trayEvent == WM_RBUTTONUP))
+			{
+				glfwShowWindow(gDrawData->window);
+				glfwRestoreWindow(gDrawData->window);
+			}
+		}
+	}
+
+	return CallNextHookEx(NULL, code, wParam, lParam);
+}
+
+void TimerToastHandler::toastActivated() const
+{
+	glfwShowWindow(gDrawData->window);
+	glfwRestoreWindow(gDrawData->window);
+}
+
+void TimerToastHandler::toastActivated(int actionIndex) const
+{
+	if (actionIndex == 0)
+	{
+		gAppData->timerData.isTimerActive = false;
+	}
+	else if (actionIndex == 1)
+	{
+		
+	}
+}
+
+void TimerToastHandler::toastFailed() const
+{
+}
+
+void TimerToastHandler::toastDismissed(WinToastDismissalReason state) const
+{
+}

AsuroTool/WindowsShell.h

@@ -0,0 +1,22 @@
+#pragma once
+#include <ImguiBase.h>
+
+#include "WinToast/wintoastlib.h"
+
+using namespace WinToastLib;
+
+struct TimerToastHandler : IWinToastHandler
+{
+	void toastActivated() const override;
+	void toastActivated(int actionIndex) const override;
+	void toastFailed() const override;
+	void toastDismissed(WinToastDismissalReason state) const override;
+};
+
+void initShell(DrawData& drawData);
+
+void showToastNotification(TimerToastHandler* handler, const wchar_t* title, const wchar_t* text, UINT64 expiresInMs = 0);
+
+void cleanupShell(DrawData& drawData);
+
+LRESULT trayIconEventHandler(int code, WPARAM wParam, LPARAM lParam);

AsuroTool/resource.h

@@ -3,12 +3,14 @@
 // Used by AsuroTool.rc
 //
 #define IDI_ICON1                       109
+#define IDS_STRING112                   112
+#define IDS_STRING_TOOLTIP              112
 
 // Next default values for new objects
 // 
 #ifdef APSTUDIO_INVOKED
 #ifndef APSTUDIO_READONLY_SYMBOLS
-#define _APS_NEXT_RESOURCE_VALUE        112
+#define _APS_NEXT_RESOURCE_VALUE        113
 #define _APS_NEXT_COMMAND_VALUE         40001
 #define _APS_NEXT_CONTROL_VALUE         1001
 #define _APS_NEXT_SYMED_VALUE           101

AsuroTool/vcpkg.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
+  "dependencies": [
+    "vulkan",
+    "vulkan-headers",
+    "glfw3",
+    {
+      "name": "imgui",
+      "features": [ "glfw-binding", "vulkan-binding" ]
+    }
+  ]
+}

ImguiBase/ImguiBase.cpp

@@ -1,12 +1,13 @@
-#include "imgui.h"
+
+#include "ImguiBase.h"
+
+// hacky inlcude for custom button alignment
+#include "imgui_internal.h"
+
 #include "imgui_impl_glfw.h"
 #include "imgui_impl_vulkan.h"
-#include "ImguiBase.h"
+
 #include <iostream>
-#define GLFW_INCLUDE_NONE
-#define GLFW_INCLUDE_VULKAN
-#define GLFW_EXPOSE_NATIVE_WIN32
-#include <GLFW/glfw3.h>
 #include <GLFW/glfw3native.h>
 #include <vulkan/vulkan.h>
 
@@ -331,7 +332,7 @@ static void glfw_error_callback(int error, const char* description)
     fprintf(stderr, "Glfw Error %d: %s\n", error, description);
 }
 
-int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void (*const drawFunc)(DrawData&, void*), const char* title, int windowWidth, int windowHeight)
+int startImgui(ImGuiCallbacks& callbacks, const char* title, int windowWidth, int windowHeight)
 {
     // Setup GLFW window
     glfwSetErrorCallback(glfw_error_callback);
@@ -339,6 +340,7 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
         return 1;
 
     glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+    glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
     GLFWwindow* window = glfwCreateWindow(windowWidth, windowHeight, title, NULL, NULL);
 
     // Setup Vulkan
@@ -365,6 +367,7 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
     // Setup Dear ImGui context
     IMGUI_CHECKVERSION();
     ImGui::CreateContext();
+
     ImGuiIO& io = ImGui::GetIO(); (void)io;
     //io.ConfigFlags |= ImGuiConfigFlags_NavEnableKeyboard;     // Enable Keyboard Controls
     //io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad;      // Enable Gamepad Controls
@@ -408,10 +411,15 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
 
     // Our state
     DrawData drawData{};
+    drawData.window = window;
     drawData.window_handle = glfwGetWin32Window(window);
     drawData.window_size = getWindowSize(window);
 
-    initFunc(drawData, customState);
+    if (callbacks.initFunc)
+    {
+        callbacks.initFunc(drawData);
+    }
+    glfwShowWindow(window);
 
     // Upload Fonts
     {
@@ -443,6 +451,12 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
         ImGui_ImplVulkan_DestroyFontUploadObjects();
     }
 
+    PerfTimer setupTimer{};
+    PerfTimer drawTimer{};
+    PerfTimer renderTimer{};
+    PerfTimer displayTimer{};
+    int drawCounter = IMGUI_REDRAW_COUNT;
+
     // Main loop
     while (!glfwWindowShouldClose(window))
     {
@@ -451,7 +465,18 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
         // - When io.WantCaptureMouse is true, do not dispatch mouse input data to your main application.
         // - When io.WantCaptureKeyboard is true, do not dispatch keyboard input data to your main application.
         // Generally you may always pass all inputs to dear imgui, and hide them from your application based on those two flags.
-        glfwPollEvents();
+        if (false && drawCounter == 0)
+        {
+            glfwWaitEvents();
+            drawCounter = IMGUI_REDRAW_COUNT;
+        }
+        else
+        {
+            glfwPollEvents();
+            drawCounter--;
+        }
+
+        setupTimer.Start();
 
         // Resize swap chain?
         if (g_SwapChainRebuild)
@@ -475,15 +500,25 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
         ImVec2 prevWindowSize = getWindowSize(window);
         drawData.window_size = prevWindowSize;
 
-        drawFunc(drawData, customState);
+        setupTimer.End();
+        drawTimer.Start();
+
+        if (callbacks.drawFunc)
+        {
+            callbacks.drawFunc(drawData);
+        }
 
         if (drawData.window_size.x != prevWindowSize.x || drawData.window_size.y != prevWindowSize.y)
         {
             glfwSetWindowSize(window, drawData.window_size.x, drawData.window_size.y);
         }
 
+        drawTimer.End();
+        renderTimer.Start();
+
         // Rendering
         ImGui::Render();
+
         ImDrawData* draw_data = ImGui::GetDrawData();
         const bool is_minimized = (draw_data->DisplaySize.x <= 0.0f || draw_data->DisplaySize.y <= 0.0f);
         if (!is_minimized)
@@ -493,11 +528,28 @@ int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void
             wd->ClearValue.color.float32[2] = drawData.clear_color.z * drawData.clear_color.w;
             wd->ClearValue.color.float32[3] = drawData.clear_color.w;
             FrameRender(wd, draw_data);
+            renderTimer.End();
+
+            displayTimer.Start();
             FramePresent(wd);
+            displayTimer.End();
         }
+        else
+        {
+            renderTimer.End();
+        }
+
+        drawData.frameTimeSetup = setupTimer.resultSeconds;
+        drawData.frameTimeDraw = drawTimer.resultSeconds;
+        drawData.frameTimeRender = renderTimer.resultSeconds;
+        drawData.frameTimeDisplay = displayTimer.resultSeconds;
     }
 
     // Cleanup
+    if (callbacks.cleanupFunc)
+    {
+        callbacks.cleanupFunc(drawData);
+    }
     err = vkDeviceWaitIdle(g_Device);
     check_vk_result(err);
     ImGui_ImplVulkan_Shutdown();
@@ -520,3 +572,120 @@ ImVec2 getWindowSize(GLFWwindow* window)
     glfwGetWindowSize(window, &window_width, &window_height);
     return ImVec2(window_width, window_height);
 }
+
+void dropShadow()
+{
+    dropShadow(DEFAULT_DROP_SHADOW_SIZE, DEFAULT_DROP_SHADOW_SIZE, ImGui::GetStyle().Colors[DEFAULT_DROP_SHADOW_COLOR_ID]);
+}
+
+void dropShadow(const float shadowSizeX, const float shadowSizeY, const ImColor& color)
+{
+    ImVec2 lastMin = ImGui::GetItemRectMin();
+    ImVec2 lastMax = ImGui::GetItemRectMax();
+    renderDropShadow(shadowSizeX, shadowSizeY, lastMin, lastMax, color);
+}
+
+void renderDropShadow(const float shadowSizeX, const float shadowSizeY, const ImVec2& min, const ImVec2& max, const ImColor& color)
+{
+    ImDrawList* windowDrawList = ImGui::GetWindowDrawList();
+    if (shadowSizeY > 0.f)
+    {
+        windowDrawList->AddQuadFilled(
+            { min.x, max.y },
+            { max.x, max.y },
+            { max.x + shadowSizeX, max.y + shadowSizeY },
+            { min.x + shadowSizeX, max.y + shadowSizeY },
+            color);
+    }
+
+    if (shadowSizeX > 0.f)
+    {
+        windowDrawList->AddQuadFilled(
+            { max.x, min.y },
+            { max.x + shadowSizeX, min.y + shadowSizeY },
+            { max.x + shadowSizeX, max.y + shadowSizeY },
+            { max.x, max.y },
+            color);
+    }
+}
+
+void dropShadowTableHeadersRow()
+{
+    ImGui::TableNextRow();
+
+    ImVec2 startPos = {};
+
+    for (int i = 0; i < ImGui::TableGetColumnCount(); i++)
+    {
+		ImGui::TableSetColumnIndex(i);
+		ImGui::TableHeader(ImGui::TableGetColumnName());
+        if (i == 0) startPos = ImGui::GetItemRectMin();
+	}
+
+    renderDropShadow(DEFAULT_DROP_SHADOW_SIZE, DEFAULT_DROP_SHADOW_SIZE, startPos, ImGui::GetItemRectMax(), ImGui::GetStyle().Colors[DEFAULT_DROP_SHADOW_COLOR_ID]);
+}
+
+void dropShadowWindowTitle()
+{
+    ImRect tempRect = ImGui::GetCurrentWindow()->ClipRect;
+    ImGui::PopClipRect();
+    dropShadow(0., 4., { .2f, .2f, .2f, .5f });
+    ImGui::PushClipRect(tempRect.Min, tempRect.Max, false);
+}
+
+bool dropButton(const char* label, const ImVec2& size, float shadowSize, bool smallButton)
+{
+    ImGuiStyle style = ImGui::GetStyle();
+    ImVec2 backupPadding = style.FramePadding;
+    if (smallButton) style.FramePadding.y = 0.f;
+
+    const ImVec2 labelSize = ImGui::CalcTextSize(label, NULL, true);
+    ImVec2 buttonMin = ImGui::GetCursorScreenPos();
+    
+    ImVec2 buttonSize = size;
+    if (buttonSize.x <= 0.f) buttonSize.x = labelSize.x + style.FramePadding.x * 2.0f;
+    if (buttonSize.y <= 0.f) buttonSize.y = labelSize.y + style.FramePadding.y * 2.0f;
+
+    float baseLineOffset = ImGui::GetCurrentWindowRead()->DC.CurrLineTextBaseOffset;
+    if (smallButton && style.FramePadding.y < baseLineOffset) buttonMin.y += baseLineOffset - style.FramePadding.y;
+
+    bool result = ImGui::InvisibleButton(label, buttonSize);
+    bool held = ImGui::IsItemActive();
+    bool hovered = ImGui::IsItemHovered();
+    const ImU32 col = ImGui::GetColorU32((held && hovered) ? ImGuiCol_ButtonActive : hovered ? ImGuiCol_ButtonHovered : ImGuiCol_Button);
+
+    float maxOffset = std::fmaxf(shadowSize - 1.f, 0.f);
+    ImVec2 offset = held ? ImVec2{ maxOffset, maxOffset } : ImVec2{ 0.f, 0.f };
+    ImVec2 rectMin = buttonMin + offset;
+    ImVec2 rectMax = buttonMin + buttonSize + offset;
+
+    ImGui::RenderFrame(rectMin, rectMax, col, true, style.FrameRounding);
+    ImGui::RenderTextClipped(rectMin, rectMax, label, NULL, &labelSize, style.ButtonTextAlign);
+
+    float realShadowSize = held ? 1.f : shadowSize;
+    renderDropShadow(realShadowSize, realShadowSize, rectMin, rectMax, ImGui::GetStyle().Colors[DEFAULT_DROP_SHADOW_COLOR_ID]);
+
+    style.FramePadding = backupPadding;
+    return result;
+}
+
+bool checkboxWithDropShadow(const char* label, bool* v, const float shadowSize)
+{
+    ImGuiStyle& style = ImGui::GetStyle();
+    float oldSpacingX = style.ItemInnerSpacing.x;
+    style.ItemInnerSpacing.x += shadowSize;
+    bool result = ImGui::Checkbox(label, v);
+    style.ItemInnerSpacing.x = oldSpacingX;
+
+    ImVec2 lastMin = ImGui::GetItemRectMin();
+    renderDropShadow(shadowSize, shadowSize, lastMin, lastMin + ImVec2{ ImGui::GetFrameHeight(), ImGui::GetFrameHeight() }, ImGui::GetStyle().Colors[DEFAULT_DROP_SHADOW_COLOR_ID]);
+    
+    return result;
+}
+
+ImVec2 operator +(const ImVec2& a, const ImVec2& b) { return ImVec2{ a.x + b.x, a.y + b.y }; }
+ImVec2 operator +(const ImVec2& a, const float s) { return ImVec2{ a.x + s, a.y + s }; }
+ImVec2 operator -(const ImVec2& a, const ImVec2& b) { return ImVec2{ a.x - b.x, a.y - b.y }; }
+ImVec2 operator -(const ImVec2& a, const float s) { return ImVec2{ a.x - s, a.y - s }; }
+ImVec2 operator *(const ImVec2& a, float s) { return ImVec2{ a.x * s, a.y * s }; }
+ImVec2 operator /(const ImVec2& a, float s) { return ImVec2{ a.x / s, a.y / s }; }

ImguiBase/ImguiBase.h

@@ -1,16 +1,87 @@
 #pragma once
-
 #include <Windows.h>
-#include "imgui_impl_glfw.h"
-#include "imgui/headers/imgui.h"
+
+#include <functional>
+
+#define GLFW_INCLUDE_NONE
+#define GLFW_INCLUDE_VULKAN
+#define GLFW_EXPOSE_NATIVE_WIN32
+#include <GLFW/glfw3.h>
+
+#include "imgui.h"
+#include "remixicon.h"
+
+#define IMGUI_REDRAW_COUNT 3
 
 class DrawData {
 public:
-	HWND window_handle = nullptr;
-	ImVec4 clear_color = {};
-	ImVec2 window_size = {};
+    GLFWwindow* window = nullptr;
+    HWND window_handle = nullptr;
+    ImVec4 clear_color = {};
+    ImVec2 window_size = {};
+    float frameTimeSetup = 0.f;
+    float frameTimeDraw = 0.f;
+    float frameTimeRender = 0.f;
+    float frameTimeDisplay = 0.f;
 };
 
-int startImgui(void* customState, void (*const initFunc)(DrawData&, void*), void (* const drawFunc)(DrawData&, void*), const char* title, int windowWidth, int windowHeight);
+class ImGuiCallbacks {
+public:
+    std::function<void(DrawData&)> initFunc = nullptr;
+    std::function<void(DrawData&)> drawFunc = nullptr;
+    std::function<void(DrawData&)> cleanupFunc = nullptr;
+};
+
+class PerfTimer {
+private:
+    LARGE_INTEGER start;
+    LARGE_INTEGER end;
+    LARGE_INTEGER freq;
+
+public:
+    LONGLONG resultTicks;
+    float resultSeconds;
+
+public:
+    void Start() {
+        QueryPerformanceFrequency(&freq);
+        QueryPerformanceCounter(&start);
+    }
+    void End() {
+        QueryPerformanceCounter(&end);
+        resultTicks = end.QuadPart - start.QuadPart;
+        resultSeconds = static_cast<float>(resultTicks * 1000) / freq.QuadPart;
+    }
+};
+
+int startImgui(ImGuiCallbacks& callbacks, const char* title, int windowWidth, int windowHeight);
 
 ImVec2 getWindowSize(GLFWwindow* window);
+
+constexpr float DEFAULT_DROP_SHADOW_SIZE = 3.f;
+constexpr ImGuiCol DEFAULT_DROP_SHADOW_COLOR_ID = ImGuiCol_TabUnfocused;
+
+void dropShadow();
+void dropShadow(const float shadowSizeX, const float shadowSizeY, const ImColor& color);
+void renderDropShadow(const float shadowSizeX, const float shadowSizeY, const ImVec2& min, const ImVec2& max, const ImColor& color);
+
+void dropShadowTableHeadersRow();
+void dropShadowWindowTitle();
+bool dropButton(const char* label, const ImVec2& size = ImVec2(0, 0), float shadowSize = DEFAULT_DROP_SHADOW_SIZE, bool smallButton = false);
+bool checkboxWithDropShadow(const char* label, bool* v, const float shadowSize = DEFAULT_DROP_SHADOW_SIZE);
+
+template <typename T>
+float calcInputWidth(const char* formatStr, T value)
+{
+    constexpr size_t MAX_BUFFER_SIZE = 256;
+    char formatStrBuffer[MAX_BUFFER_SIZE];
+    snprintf(formatStrBuffer, MAX_BUFFER_SIZE, formatStr, value);
+    return ImGui::CalcTextSize(formatStrBuffer).x + ImGui::GetStyle().FramePadding.x * 2.f;
+}
+
+ImVec2 operator +(const ImVec2& a, const ImVec2& b);
+ImVec2 operator +(const ImVec2& a, const float s);
+ImVec2 operator -(const ImVec2& a, const ImVec2& b);
+ImVec2 operator -(const ImVec2& a, const float s);
+ImVec2 operator *(const ImVec2& a, float s);
+ImVec2 operator /(const ImVec2& a, float s);

ImguiBase/ImguiBase.vcxproj

@@ -72,23 +72,28 @@
   <PropertyGroup Label="UserMacros" />
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>imgui/headers;D:\Applications\VulkanSDK\1.2.182.0\Include;E:\Code\glfw-3.3.7.bin.WIN64\include;$(IncludePath)</IncludePath>
-    <PublicIncludeDirectories>imgui\headers;E:\Code\glfw-3.3.7.bin.WIN64\include;D:\Applications\VulkanSDK\1.2.182.0\Include</PublicIncludeDirectories>
+    <IncludePath>$(VULKAN_SDK)/include</IncludePath>
+    <PublicIncludeDirectories>$(VULKAN_SDK)/include</PublicIncludeDirectories>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>imgui/headers;D:\Applications\VulkanSDK\1.2.182.0\Include;E:\Code\glfw-3.3.7.bin.WIN64\include;$(IncludePath)</IncludePath>
-    <PublicIncludeDirectories>imgui\headers;E:\Code\glfw-3.3.7.bin.WIN64\include;D:\Applications\VulkanSDK\1.2.182.0\Include</PublicIncludeDirectories>
+    <IncludePath>$(VULKAN_SDK)/include</IncludePath>
+    <PublicIncludeDirectories>$(VULKAN_SDK)/include</PublicIncludeDirectories>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
     <LinkIncremental>true</LinkIncremental>
-    <IncludePath>imgui/headers;D:\Applications\VulkanSDK\1.2.182.0\Include;E:\Code\glfw-3.3.7.bin.WIN64\include;$(IncludePath)</IncludePath>
-    <PublicIncludeDirectories>imgui\headers;E:\Code\glfw-3.3.7.bin.WIN64\include;D:\Applications\VulkanSDK\1.2.182.0\Include</PublicIncludeDirectories>
+    <IncludePath>$(VULKAN_SDK)/include</IncludePath>
+    <PublicIncludeDirectories>$(VULKAN_SDK)/include</PublicIncludeDirectories>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(VULKAN_SDK)/Lib</LibraryPath>
   </PropertyGroup>
   <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
     <LinkIncremental>false</LinkIncremental>
-    <IncludePath>imgui/headers;D:\Applications\VulkanSDK\1.2.182.0\Include;E:\Code\glfw-3.3.7.bin.WIN64\include;$(IncludePath)</IncludePath>
-    <PublicIncludeDirectories>imgui\headers;E:\Code\glfw-3.3.7.bin.WIN64\include;D:\Applications\VulkanSDK\1.2.182.0\Include</PublicIncludeDirectories>
+    <IncludePath>$(VULKAN_SDK)/include</IncludePath>
+    <PublicIncludeDirectories>$(VULKAN_SDK)/include</PublicIncludeDirectories>
+    <LibraryPath>$(VC_LibraryPath_x64);$(WindowsSDK_LibraryPath_x64);$(VULKAN_SDK)/Lib</LibraryPath>
+  </PropertyGroup>
+  <PropertyGroup Label="Vcpkg">
+    <VcpkgEnableManifest>true</VcpkgEnableManifest>
   </PropertyGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
     <ClCompile>
@@ -107,6 +112,8 @@
     <Lib>
       <AdditionalLibraryDirectories>E:\Code\glfw-3.3.7.bin.WIN64\lib-vc2022;D:\Applications\VulkanSDK\1.2.182.0\Lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>vulkan-1.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Lib>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
@@ -130,6 +137,8 @@
     <Lib>
       <AdditionalLibraryDirectories>E:\Code\glfw-3.3.7.bin.WIN64\lib-vc2022;D:\Applications\VulkanSDK\1.2.182.0\Lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
       <AdditionalDependencies>vulkan-1.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Lib>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
@@ -147,8 +156,10 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
     <Lib>
-      <AdditionalLibraryDirectories>E:\Code\glfw-3.3.7.bin.WIN64\lib-vc2022;D:\Applications\VulkanSDK\1.2.182.0\Lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>vulkan-1.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Lib>
   </ItemDefinitionGroup>
   <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
@@ -170,34 +181,25 @@
       <GenerateDebugInformation>true</GenerateDebugInformation>
     </Link>
     <Lib>
-      <AdditionalLibraryDirectories>E:\Code\glfw-3.3.7.bin.WIN64\lib-vc2022;D:\Applications\VulkanSDK\1.2.182.0\Lib;%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
-      <AdditionalDependencies>vulkan-1.lib;glfw3.lib;%(AdditionalDependencies)</AdditionalDependencies>
+      <AdditionalLibraryDirectories>%(AdditionalLibraryDirectories)</AdditionalLibraryDirectories>
+      <AdditionalDependencies>%(AdditionalDependencies)</AdditionalDependencies>
+      <IgnoreSpecificDefaultLibraries>
+      </IgnoreSpecificDefaultLibraries>
     </Lib>
   </ItemDefinitionGroup>
   <ItemGroup>
     <ClCompile Include="ImguiBase.cpp" />
-    <ClCompile Include="imgui\code\imgui.cpp" />
-    <ClCompile Include="imgui\code\imgui_demo.cpp" />
-    <ClCompile Include="imgui\code\imgui_draw.cpp" />
-    <ClCompile Include="imgui\code\imgui_impl_glfw.cpp" />
-    <ClCompile Include="imgui\code\imgui_impl_vulkan.cpp" />
-    <ClCompile Include="imgui\code\imgui_tables.cpp" />
-    <ClCompile Include="imgui\code\imgui_widgets.cpp" />
   </ItemGroup>
   <ItemGroup>
     <ClInclude Include="ImguiBase.h" />
-    <ClInclude Include="imgui\headers\imconfig.h" />
-    <ClInclude Include="imgui\headers\imgui.h" />
-    <ClInclude Include="imgui\headers\imgui_impl_glfw.h" />
-    <ClInclude Include="imgui\headers\imgui_impl_vulkan.h" />
-    <ClInclude Include="imgui\headers\imgui_internal.h" />
-    <ClInclude Include="imgui\headers\imstb_rectpack.h" />
-    <ClInclude Include="imgui\headers\imstb_textedit.h" />
-    <ClInclude Include="imgui\headers\imstb_truetype.h" />
+    <ClInclude Include="remixicon.h" />
   </ItemGroup>
   <ItemGroup>
     <Font Include="Montserrat-Regular.ttf" />
   </ItemGroup>
+  <ItemGroup>
+    <None Include="vcpkg.json" />
+  </ItemGroup>
   <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
   <ImportGroup Label="ExtensionTargets">
   </ImportGroup>

ImguiBase/ImguiBase.vcxproj.filters

@@ -24,60 +24,21 @@
     <ClCompile Include="ImguiBase.cpp">
       <Filter>Source Files</Filter>
     </ClCompile>
-    <ClCompile Include="imgui\code\imgui_impl_glfw.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
-    <ClCompile Include="imgui\code\imgui.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
-    <ClCompile Include="imgui\code\imgui_demo.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
-    <ClCompile Include="imgui\code\imgui_draw.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
-    <ClCompile Include="imgui\code\imgui_impl_vulkan.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
-    <ClCompile Include="imgui\code\imgui_tables.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
-    <ClCompile Include="imgui\code\imgui_widgets.cpp">
-      <Filter>Source Files\imgui</Filter>
-    </ClCompile>
   </ItemGroup>
   <ItemGroup>
-    <ClInclude Include="imgui\headers\imconfig.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imgui.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imgui_impl_glfw.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imgui_impl_vulkan.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imgui_internal.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imstb_rectpack.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imstb_textedit.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
-    <ClInclude Include="imgui\headers\imstb_truetype.h">
-      <Filter>Header Files\imgui</Filter>
-    </ClInclude>
     <ClInclude Include="ImguiBase.h">
       <Filter>Header Files</Filter>
     </ClInclude>
+    <ClInclude Include="remixicon.h">
+      <Filter>Header Files</Filter>
+    </ClInclude>
   </ItemGroup>
   <ItemGroup>
     <Font Include="Montserrat-Regular.ttf">
       <Filter>Resource Files</Filter>
     </Font>
   </ItemGroup>
+  <ItemGroup>
+    <None Include="vcpkg.json" />
+  </ItemGroup>
 </Project>

ImguiBase/imgui/code/imgui_impl_glfw.cpp

@@ -1,643 +0,0 @@
-// dear imgui: Platform Backend for GLFW
-// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
-// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
-// (Requires: GLFW 3.1+)
-
-// Implemented features:
-//  [X] Platform: Clipboard support.
-//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
-//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
-//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
-
-// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
-// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
-// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
-// Read online: https://github.com/ocornut/imgui/tree/master/docs
-
-// CHANGELOG
-// (minor and older changes stripped away, please see git history for details)
-//  2022-02-07: Added ImGui_ImplGlfw_InstallCallbacks()/ImGui_ImplGlfw_RestoreCallbacks() helpers to facilitate user installing callbacks after iniitializing backend.
-//  2022-01-26: Inputs: replaced short-lived io.AddKeyModsEvent() (added two weeks ago)with io.AddKeyEvent() using ImGuiKey_ModXXX flags. Sorry for the confusion.
-//  2021-01-20: Inputs: calling new io.AddKeyAnalogEvent() for gamepad support, instead of writing directly to io.NavInputs[].
-//  2022-01-17: Inputs: calling new io.AddMousePosEvent(), io.AddMouseButtonEvent(), io.AddMouseWheelEvent() API (1.87+).
-//  2022-01-17: Inputs: always update key mods next and before key event (not in NewFrame) to fix input queue with very low framerates.
-//  2022-01-12: *BREAKING CHANGE*: Now using glfwSetCursorPosCallback(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetCursorPosCallback() and forward it to the backend via ImGui_ImplGlfw_CursorPosCallback().
-//  2022-01-10: Inputs: calling new io.AddKeyEvent(), io.AddKeyModsEvent() + io.SetKeyEventNativeData() API (1.87+). Support for full ImGuiKey range.
-//  2022-01-05: Inputs: Converting GLFW untranslated keycodes back to translated keycodes (in the ImGui_ImplGlfw_KeyCallback() function) in order to match the behavior of every other backend, and facilitate the use of GLFW with lettered-shortcuts API.
-//  2021-08-17: *BREAKING CHANGE*: Now using glfwSetWindowFocusCallback() to calling io.AddFocusEvent(). If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() and forward it to the backend via ImGui_ImplGlfw_WindowFocusCallback().
-//  2021-07-29: *BREAKING CHANGE*: Now using glfwSetCursorEnterCallback(). MousePos is correctly reported when the host platform window is hovered but not focused. If you called ImGui_ImplGlfw_InitXXX() with install_callbacks = false, you MUST install glfwSetWindowFocusCallback() callback and forward it to the backend via ImGui_ImplGlfw_CursorEnterCallback().
-//  2021-06-29: Reorganized backend to pull data from a single structure to facilitate usage with multiple-contexts (all g_XXXX access changed to bd->XXXX).
-//  2020-01-17: Inputs: Disable error callback while assigning mouse cursors because some X11 setup don't have them and it generates errors.
-//  2019-12-05: Inputs: Added support for new mouse cursors added in GLFW 3.4+ (resizing cursors, not allowed cursor).
-//  2019-10-18: Misc: Previously installed user callbacks are now restored on shutdown.
-//  2019-07-21: Inputs: Added mapping for ImGuiKey_KeyPadEnter.
-//  2019-05-11: Inputs: Don't filter value from character callback before calling AddInputCharacter().
-//  2019-03-12: Misc: Preserve DisplayFramebufferScale when main window is minimized.
-//  2018-11-30: Misc: Setting up io.BackendPlatformName so it can be displayed in the About Window.
-//  2018-11-07: Inputs: When installing our GLFW callbacks, we save user's previously installed ones - if any - and chain call them.
-//  2018-08-01: Inputs: Workaround for Emscripten which doesn't seem to handle focus related calls.
-//  2018-06-29: Inputs: Added support for the ImGuiMouseCursor_Hand cursor.
-//  2018-06-08: Misc: Extracted imgui_impl_glfw.cpp/.h away from the old combined GLFW+OpenGL/Vulkan examples.
-//  2018-03-20: Misc: Setup io.BackendFlags ImGuiBackendFlags_HasMouseCursors flag + honor ImGuiConfigFlags_NoMouseCursorChange flag.
-//  2018-02-20: Inputs: Added support for mouse cursors (ImGui::GetMouseCursor() value, passed to glfwSetCursor()).
-//  2018-02-06: Misc: Removed call to ImGui::Shutdown() which is not available from 1.60 WIP, user needs to call CreateContext/DestroyContext themselves.
-//  2018-02-06: Inputs: Added mapping for ImGuiKey_Space.
-//  2018-01-25: Inputs: Added gamepad support if ImGuiConfigFlags_NavEnableGamepad is set.
-//  2018-01-25: Inputs: Honoring the io.WantSetMousePos by repositioning the mouse (when using navigation and ImGuiConfigFlags_NavMoveMouse is set).
-//  2018-01-20: Inputs: Added Horizontal Mouse Wheel support.
-//  2018-01-18: Inputs: Added mapping for ImGuiKey_Insert.
-//  2017-08-25: Inputs: MousePos set to -FLT_MAX,-FLT_MAX when mouse is unavailable/missing (instead of -1,-1).
-//  2016-10-15: Misc: Added a void* user_data parameter to Clipboard function handlers.
-
-#include "imgui.h"
-#include "imgui_impl_glfw.h"
-
-// Clang warnings with -Weverything
-#if defined(__clang__)
-#pragma clang diagnostic push
-#pragma clang diagnostic ignored "-Wold-style-cast"     // warning: use of old-style cast
-#pragma clang diagnostic ignored "-Wsign-conversion"    // warning: implicit conversion changes signedness
-#if __has_warning("-Wzero-as-null-pointer-constant")
-#pragma clang diagnostic ignored "-Wzero-as-null-pointer-constant"
-#endif
-#endif
-
-// GLFW
-#include <GLFW/glfw3.h>
-#ifdef _WIN32
-#undef APIENTRY
-#define GLFW_EXPOSE_NATIVE_WIN32
-#include <GLFW/glfw3native.h>   // for glfwGetWin32Window
-#endif
-#ifdef GLFW_RESIZE_NESW_CURSOR        // Let's be nice to people who pulled GLFW between 2019-04-16 (3.4 define) and 2019-11-29 (cursors defines) // FIXME: Remove when GLFW 3.4 is released?
-#define GLFW_HAS_NEW_CURSORS          (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3400) // 3.4+ GLFW_RESIZE_ALL_CURSOR, GLFW_RESIZE_NESW_CURSOR, GLFW_RESIZE_NWSE_CURSOR, GLFW_NOT_ALLOWED_CURSOR
-#else
-#define GLFW_HAS_NEW_CURSORS          (0)
-#endif
-#define GLFW_HAS_GAMEPAD_API          (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3300) // 3.3+ glfwGetGamepadState() new api
-#define GLFW_HAS_GET_KEY_NAME         (GLFW_VERSION_MAJOR * 1000 + GLFW_VERSION_MINOR * 100 >= 3200) // 3.2+ glfwGetKeyName()
-
-// GLFW data
-enum GlfwClientApi
-{
-    GlfwClientApi_Unknown,
-    GlfwClientApi_OpenGL,
-    GlfwClientApi_Vulkan
-};
-
-struct ImGui_ImplGlfw_Data
-{
-    GLFWwindow*             Window;
-    GlfwClientApi           ClientApi;
-    double                  Time;
-    GLFWwindow*             MouseWindow;
-    GLFWcursor*             MouseCursors[ImGuiMouseCursor_COUNT];
-    ImVec2                  LastValidMousePos;
-    bool                    InstalledCallbacks;
-
-    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
-    GLFWwindowfocusfun      PrevUserCallbackWindowFocus;
-    GLFWcursorposfun        PrevUserCallbackCursorPos;
-    GLFWcursorenterfun      PrevUserCallbackCursorEnter;
-    GLFWmousebuttonfun      PrevUserCallbackMousebutton;
-    GLFWscrollfun           PrevUserCallbackScroll;
-    GLFWkeyfun              PrevUserCallbackKey;
-    GLFWcharfun             PrevUserCallbackChar;
-    GLFWmonitorfun          PrevUserCallbackMonitor;
-
-    ImGui_ImplGlfw_Data()   { memset(this, 0, sizeof(*this)); }
-};
-
-// Backend data stored in io.BackendPlatformUserData to allow support for multiple Dear ImGui contexts
-// It is STRONGLY preferred that you use docking branch with multi-viewports (== single Dear ImGui context + multiple windows) instead of multiple Dear ImGui contexts.
-// FIXME: multi-context support is not well tested and probably dysfunctional in this backend.
-// - Because glfwPollEvents() process all windows and some events may be called outside of it, you will need to register your own callbacks
-//   (passing install_callbacks=false in ImGui_ImplGlfw_InitXXX functions), set the current dear imgui context and then call our callbacks.
-// - Otherwise we may need to store a GLFWWindow* -> ImGuiContext* map and handle this in the backend, adding a little bit of extra complexity to it.
-// FIXME: some shared resources (mouse cursor shape, gamepad) are mishandled when using multi-context.
-static ImGui_ImplGlfw_Data* ImGui_ImplGlfw_GetBackendData()
-{
-    return ImGui::GetCurrentContext() ? (ImGui_ImplGlfw_Data*)ImGui::GetIO().BackendPlatformUserData : NULL;
-}
-
-// Functions
-static const char* ImGui_ImplGlfw_GetClipboardText(void* user_data)
-{
-    return glfwGetClipboardString((GLFWwindow*)user_data);
-}
-
-static void ImGui_ImplGlfw_SetClipboardText(void* user_data, const char* text)
-{
-    glfwSetClipboardString((GLFWwindow*)user_data, text);
-}
-
-static ImGuiKey ImGui_ImplGlfw_KeyToImGuiKey(int key)
-{
-    switch (key)
-    {
-        case GLFW_KEY_TAB: return ImGuiKey_Tab;
-        case GLFW_KEY_LEFT: return ImGuiKey_LeftArrow;
-        case GLFW_KEY_RIGHT: return ImGuiKey_RightArrow;
-        case GLFW_KEY_UP: return ImGuiKey_UpArrow;
-        case GLFW_KEY_DOWN: return ImGuiKey_DownArrow;
-        case GLFW_KEY_PAGE_UP: return ImGuiKey_PageUp;
-        case GLFW_KEY_PAGE_DOWN: return ImGuiKey_PageDown;
-        case GLFW_KEY_HOME: return ImGuiKey_Home;
-        case GLFW_KEY_END: return ImGuiKey_End;
-        case GLFW_KEY_INSERT: return ImGuiKey_Insert;
-        case GLFW_KEY_DELETE: return ImGuiKey_Delete;
-        case GLFW_KEY_BACKSPACE: return ImGuiKey_Backspace;
-        case GLFW_KEY_SPACE: return ImGuiKey_Space;
-        case GLFW_KEY_ENTER: return ImGuiKey_Enter;
-        case GLFW_KEY_ESCAPE: return ImGuiKey_Escape;
-        case GLFW_KEY_APOSTROPHE: return ImGuiKey_Apostrophe;
-        case GLFW_KEY_COMMA: return ImGuiKey_Comma;
-        case GLFW_KEY_MINUS: return ImGuiKey_Minus;
-        case GLFW_KEY_PERIOD: return ImGuiKey_Period;
-        case GLFW_KEY_SLASH: return ImGuiKey_Slash;
-        case GLFW_KEY_SEMICOLON: return ImGuiKey_Semicolon;
-        case GLFW_KEY_EQUAL: return ImGuiKey_Equal;
-        case GLFW_KEY_LEFT_BRACKET: return ImGuiKey_LeftBracket;
-        case GLFW_KEY_BACKSLASH: return ImGuiKey_Backslash;
-        case GLFW_KEY_RIGHT_BRACKET: return ImGuiKey_RightBracket;
-        case GLFW_KEY_GRAVE_ACCENT: return ImGuiKey_GraveAccent;
-        case GLFW_KEY_CAPS_LOCK: return ImGuiKey_CapsLock;
-        case GLFW_KEY_SCROLL_LOCK: return ImGuiKey_ScrollLock;
-        case GLFW_KEY_NUM_LOCK: return ImGuiKey_NumLock;
-        case GLFW_KEY_PRINT_SCREEN: return ImGuiKey_PrintScreen;
-        case GLFW_KEY_PAUSE: return ImGuiKey_Pause;
-        case GLFW_KEY_KP_0: return ImGuiKey_Keypad0;
-        case GLFW_KEY_KP_1: return ImGuiKey_Keypad1;
-        case GLFW_KEY_KP_2: return ImGuiKey_Keypad2;
-        case GLFW_KEY_KP_3: return ImGuiKey_Keypad3;
-        case GLFW_KEY_KP_4: return ImGuiKey_Keypad4;
-        case GLFW_KEY_KP_5: return ImGuiKey_Keypad5;
-        case GLFW_KEY_KP_6: return ImGuiKey_Keypad6;
-        case GLFW_KEY_KP_7: return ImGuiKey_Keypad7;
-        case GLFW_KEY_KP_8: return ImGuiKey_Keypad8;
-        case GLFW_KEY_KP_9: return ImGuiKey_Keypad9;
-        case GLFW_KEY_KP_DECIMAL: return ImGuiKey_KeypadDecimal;
-        case GLFW_KEY_KP_DIVIDE: return ImGuiKey_KeypadDivide;
-        case GLFW_KEY_KP_MULTIPLY: return ImGuiKey_KeypadMultiply;
-        case GLFW_KEY_KP_SUBTRACT: return ImGuiKey_KeypadSubtract;
-        case GLFW_KEY_KP_ADD: return ImGuiKey_KeypadAdd;
-        case GLFW_KEY_KP_ENTER: return ImGuiKey_KeypadEnter;
-        case GLFW_KEY_KP_EQUAL: return ImGuiKey_KeypadEqual;
-        case GLFW_KEY_LEFT_SHIFT: return ImGuiKey_LeftShift;
-        case GLFW_KEY_LEFT_CONTROL: return ImGuiKey_LeftCtrl;
-        case GLFW_KEY_LEFT_ALT: return ImGuiKey_LeftAlt;
-        case GLFW_KEY_LEFT_SUPER: return ImGuiKey_LeftSuper;
-        case GLFW_KEY_RIGHT_SHIFT: return ImGuiKey_RightShift;
-        case GLFW_KEY_RIGHT_CONTROL: return ImGuiKey_RightCtrl;
-        case GLFW_KEY_RIGHT_ALT: return ImGuiKey_RightAlt;
-        case GLFW_KEY_RIGHT_SUPER: return ImGuiKey_RightSuper;
-        case GLFW_KEY_MENU: return ImGuiKey_Menu;
-        case GLFW_KEY_0: return ImGuiKey_0;
-        case GLFW_KEY_1: return ImGuiKey_1;
-        case GLFW_KEY_2: return ImGuiKey_2;
-        case GLFW_KEY_3: return ImGuiKey_3;
-        case GLFW_KEY_4: return ImGuiKey_4;
-        case GLFW_KEY_5: return ImGuiKey_5;
-        case GLFW_KEY_6: return ImGuiKey_6;
-        case GLFW_KEY_7: return ImGuiKey_7;
-        case GLFW_KEY_8: return ImGuiKey_8;
-        case GLFW_KEY_9: return ImGuiKey_9;
-        case GLFW_KEY_A: return ImGuiKey_A;
-        case GLFW_KEY_B: return ImGuiKey_B;
-        case GLFW_KEY_C: return ImGuiKey_C;
-        case GLFW_KEY_D: return ImGuiKey_D;
-        case GLFW_KEY_E: return ImGuiKey_E;
-        case GLFW_KEY_F: return ImGuiKey_F;
-        case GLFW_KEY_G: return ImGuiKey_G;
-        case GLFW_KEY_H: return ImGuiKey_H;
-        case GLFW_KEY_I: return ImGuiKey_I;
-        case GLFW_KEY_J: return ImGuiKey_J;
-        case GLFW_KEY_K: return ImGuiKey_K;
-        case GLFW_KEY_L: return ImGuiKey_L;
-        case GLFW_KEY_M: return ImGuiKey_M;
-        case GLFW_KEY_N: return ImGuiKey_N;
-        case GLFW_KEY_O: return ImGuiKey_O;
-        case GLFW_KEY_P: return ImGuiKey_P;
-        case GLFW_KEY_Q: return ImGuiKey_Q;
-        case GLFW_KEY_R: return ImGuiKey_R;
-        case GLFW_KEY_S: return ImGuiKey_S;
-        case GLFW_KEY_T: return ImGuiKey_T;
-        case GLFW_KEY_U: return ImGuiKey_U;
-        case GLFW_KEY_V: return ImGuiKey_V;
-        case GLFW_KEY_W: return ImGuiKey_W;
-        case GLFW_KEY_X: return ImGuiKey_X;
-        case GLFW_KEY_Y: return ImGuiKey_Y;
-        case GLFW_KEY_Z: return ImGuiKey_Z;
-        case GLFW_KEY_F1: return ImGuiKey_F1;
-        case GLFW_KEY_F2: return ImGuiKey_F2;
-        case GLFW_KEY_F3: return ImGuiKey_F3;
-        case GLFW_KEY_F4: return ImGuiKey_F4;
-        case GLFW_KEY_F5: return ImGuiKey_F5;
-        case GLFW_KEY_F6: return ImGuiKey_F6;
-        case GLFW_KEY_F7: return ImGuiKey_F7;
-        case GLFW_KEY_F8: return ImGuiKey_F8;
-        case GLFW_KEY_F9: return ImGuiKey_F9;
-        case GLFW_KEY_F10: return ImGuiKey_F10;
-        case GLFW_KEY_F11: return ImGuiKey_F11;
-        case GLFW_KEY_F12: return ImGuiKey_F12;
-        default: return ImGuiKey_None;
-    }
-}
-
-static void ImGui_ImplGlfw_UpdateKeyModifiers(int mods)
-{
-    ImGuiIO& io = ImGui::GetIO();
-    io.AddKeyEvent(ImGuiKey_ModCtrl, (mods & GLFW_MOD_CONTROL) != 0);
-    io.AddKeyEvent(ImGuiKey_ModShift, (mods & GLFW_MOD_SHIFT) != 0);
-    io.AddKeyEvent(ImGuiKey_ModAlt, (mods & GLFW_MOD_ALT) != 0);
-    io.AddKeyEvent(ImGuiKey_ModSuper, (mods & GLFW_MOD_SUPER) != 0);
-}
-
-void ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackMousebutton != NULL && window == bd->Window)
-        bd->PrevUserCallbackMousebutton(window, button, action, mods);
-
-    ImGui_ImplGlfw_UpdateKeyModifiers(mods);
-
-    ImGuiIO& io = ImGui::GetIO();
-    if (button >= 0 && button < ImGuiMouseButton_COUNT)
-        io.AddMouseButtonEvent(button, action == GLFW_PRESS);
-}
-
-void ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackScroll != NULL && window == bd->Window)
-        bd->PrevUserCallbackScroll(window, xoffset, yoffset);
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.AddMouseWheelEvent((float)xoffset, (float)yoffset);
-}
-
-static int ImGui_ImplGlfw_TranslateUntranslatedKey(int key, int scancode)
-{
-#if GLFW_HAS_GET_KEY_NAME && !defined(__EMSCRIPTEN__)
-    // GLFW 3.1+ attempts to "untranslate" keys, which goes the opposite of what every other framework does, making using lettered shortcuts difficult.
-    // (It had reasons to do so: namely GLFW is/was more likely to be used for WASD-type game controls rather than lettered shortcuts, but IHMO the 3.1 change could have been done differently)
-    // See https://github.com/glfw/glfw/issues/1502 for details.
-    // Adding a workaround to undo this (so our keys are translated->untranslated->translated, likely a lossy process).
-    // This won't cover edge cases but this is at least going to cover common cases.
-    if (key >= GLFW_KEY_KP_0 && key <= GLFW_KEY_KP_EQUAL)
-        return key;
-    const char* key_name = glfwGetKeyName(key, scancode);
-    if (key_name && key_name[0] != 0 && key_name[1] == 0)
-    {
-        const char char_names[] = "`-=[]\\,;\'./";
-        const int char_keys[] = { GLFW_KEY_GRAVE_ACCENT, GLFW_KEY_MINUS, GLFW_KEY_EQUAL, GLFW_KEY_LEFT_BRACKET, GLFW_KEY_RIGHT_BRACKET, GLFW_KEY_BACKSLASH, GLFW_KEY_COMMA, GLFW_KEY_SEMICOLON, GLFW_KEY_APOSTROPHE, GLFW_KEY_PERIOD, GLFW_KEY_SLASH, 0 };
-        IM_ASSERT(IM_ARRAYSIZE(char_names) == IM_ARRAYSIZE(char_keys));
-        if (key_name[0] >= '0' && key_name[0] <= '9')               { key = GLFW_KEY_0 + (key_name[0] - '0'); }
-        else if (key_name[0] >= 'A' && key_name[0] <= 'Z')          { key = GLFW_KEY_A + (key_name[0] - 'A'); }
-        else if (const char* p = strchr(char_names, key_name[0]))   { key = char_keys[p - char_names]; }
-    }
-    // if (action == GLFW_PRESS) printf("key %d scancode %d name '%s'\n", key, scancode, key_name);
-#else
-    IM_UNUSED(scancode);
-#endif
-    return key;
-}
-
-void ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int keycode, int scancode, int action, int mods)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackKey != NULL && window == bd->Window)
-        bd->PrevUserCallbackKey(window, keycode, scancode, action, mods);
-
-    if (action != GLFW_PRESS && action != GLFW_RELEASE)
-        return;
-
-    ImGui_ImplGlfw_UpdateKeyModifiers(mods);
-
-    keycode = ImGui_ImplGlfw_TranslateUntranslatedKey(keycode, scancode);
-
-    ImGuiIO& io = ImGui::GetIO();
-    ImGuiKey imgui_key = ImGui_ImplGlfw_KeyToImGuiKey(keycode);
-    io.AddKeyEvent(imgui_key, (action == GLFW_PRESS));
-    io.SetKeyEventNativeData(imgui_key, keycode, scancode); // To support legacy indexing (<1.87 user code)
-}
-
-void ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackWindowFocus != NULL && window == bd->Window)
-        bd->PrevUserCallbackWindowFocus(window, focused);
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.AddFocusEvent(focused != 0);
-}
-
-void ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackCursorPos != NULL && window == bd->Window)
-        bd->PrevUserCallbackCursorPos(window, x, y);
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.AddMousePosEvent((float)x, (float)y);
-    bd->LastValidMousePos = ImVec2((float)x, (float)y);
-}
-
-// Workaround: X11 seems to send spurious Leave/Enter events which would make us lose our position,
-// so we back it up and restore on Leave/Enter (see https://github.com/ocornut/imgui/issues/4984)
-void ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackCursorEnter != NULL && window == bd->Window)
-        bd->PrevUserCallbackCursorEnter(window, entered);
-
-    ImGuiIO& io = ImGui::GetIO();
-    if (entered)
-    {
-        bd->MouseWindow = window;
-        io.AddMousePosEvent(bd->LastValidMousePos.x, bd->LastValidMousePos.y);
-    }
-    else if (!entered && bd->MouseWindow == window)
-    {
-        bd->LastValidMousePos = io.MousePos;
-        bd->MouseWindow = NULL;
-        io.AddMousePosEvent(-FLT_MAX, -FLT_MAX);
-    }
-}
-
-void ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if (bd->PrevUserCallbackChar != NULL && window == bd->Window)
-        bd->PrevUserCallbackChar(window, c);
-
-    ImGuiIO& io = ImGui::GetIO();
-    io.AddInputCharacter(c);
-}
-
-void ImGui_ImplGlfw_MonitorCallback(GLFWmonitor*, int)
-{
-	// Unused in 'master' branch but 'docking' branch will use this, so we declare it ahead of it so if you have to install callbacks you can install this one too.
-}
-
-void ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    IM_ASSERT(bd->InstalledCallbacks == false && "Callbacks already installed!");
-    IM_ASSERT(bd->Window == window);
-
-    bd->PrevUserCallbackWindowFocus = glfwSetWindowFocusCallback(window, ImGui_ImplGlfw_WindowFocusCallback);
-    bd->PrevUserCallbackCursorEnter = glfwSetCursorEnterCallback(window, ImGui_ImplGlfw_CursorEnterCallback);
-    bd->PrevUserCallbackCursorPos = glfwSetCursorPosCallback(window, ImGui_ImplGlfw_CursorPosCallback);
-    bd->PrevUserCallbackMousebutton = glfwSetMouseButtonCallback(window, ImGui_ImplGlfw_MouseButtonCallback);
-    bd->PrevUserCallbackScroll = glfwSetScrollCallback(window, ImGui_ImplGlfw_ScrollCallback);
-    bd->PrevUserCallbackKey = glfwSetKeyCallback(window, ImGui_ImplGlfw_KeyCallback);
-    bd->PrevUserCallbackChar = glfwSetCharCallback(window, ImGui_ImplGlfw_CharCallback);
-    bd->PrevUserCallbackMonitor = glfwSetMonitorCallback(ImGui_ImplGlfw_MonitorCallback);
-    bd->InstalledCallbacks = true;
-}
-
-void ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window)
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    IM_ASSERT(bd->InstalledCallbacks == true && "Callbacks not installed!");
-    IM_ASSERT(bd->Window == window);
-
-    glfwSetWindowFocusCallback(window, bd->PrevUserCallbackWindowFocus);
-    glfwSetCursorEnterCallback(window, bd->PrevUserCallbackCursorEnter);
-    glfwSetCursorPosCallback(window, bd->PrevUserCallbackCursorPos);
-    glfwSetMouseButtonCallback(window, bd->PrevUserCallbackMousebutton);
-    glfwSetScrollCallback(window, bd->PrevUserCallbackScroll);
-    glfwSetKeyCallback(window, bd->PrevUserCallbackKey);
-    glfwSetCharCallback(window, bd->PrevUserCallbackChar);
-    glfwSetMonitorCallback(bd->PrevUserCallbackMonitor);
-    bd->InstalledCallbacks = false;
-    bd->PrevUserCallbackWindowFocus = NULL;
-    bd->PrevUserCallbackCursorEnter = NULL;
-    bd->PrevUserCallbackCursorPos = NULL;
-    bd->PrevUserCallbackMousebutton = NULL;
-    bd->PrevUserCallbackScroll = NULL;
-    bd->PrevUserCallbackKey = NULL;
-    bd->PrevUserCallbackChar = NULL;
-    bd->PrevUserCallbackMonitor = NULL;
-}
-
-static bool ImGui_ImplGlfw_Init(GLFWwindow* window, bool install_callbacks, GlfwClientApi client_api)
-{
-    ImGuiIO& io = ImGui::GetIO();
-    IM_ASSERT(io.BackendPlatformUserData == NULL && "Already initialized a platform backend!");
-
-    // Setup backend capabilities flags
-    ImGui_ImplGlfw_Data* bd = IM_NEW(ImGui_ImplGlfw_Data)();
-    io.BackendPlatformUserData = (void*)bd;
-    io.BackendPlatformName = "imgui_impl_glfw";
-    io.BackendFlags |= ImGuiBackendFlags_HasMouseCursors;         // We can honor GetMouseCursor() values (optional)
-    io.BackendFlags |= ImGuiBackendFlags_HasSetMousePos;          // We can honor io.WantSetMousePos requests (optional, rarely used)
-
-    bd->Window = window;
-    bd->Time = 0.0;
-
-    io.SetClipboardTextFn = ImGui_ImplGlfw_SetClipboardText;
-    io.GetClipboardTextFn = ImGui_ImplGlfw_GetClipboardText;
-    io.ClipboardUserData = bd->Window;
-
-    // Set platform dependent data in viewport
-#if defined(_WIN32)
-    ImGui::GetMainViewport()->PlatformHandleRaw = (void*)glfwGetWin32Window(bd->Window);
-#endif
-
-    // Create mouse cursors
-    // (By design, on X11 cursors are user configurable and some cursors may be missing. When a cursor doesn't exist,
-    // GLFW will emit an error which will often be printed by the app, so we temporarily disable error reporting.
-    // Missing cursors will return NULL and our _UpdateMouseCursor() function will use the Arrow cursor instead.)
-    GLFWerrorfun prev_error_callback = glfwSetErrorCallback(NULL);
-    bd->MouseCursors[ImGuiMouseCursor_Arrow] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_TextInput] = glfwCreateStandardCursor(GLFW_IBEAM_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_ResizeNS] = glfwCreateStandardCursor(GLFW_VRESIZE_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_ResizeEW] = glfwCreateStandardCursor(GLFW_HRESIZE_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_Hand] = glfwCreateStandardCursor(GLFW_HAND_CURSOR);
-#if GLFW_HAS_NEW_CURSORS
-    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_RESIZE_ALL_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_RESIZE_NESW_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_RESIZE_NWSE_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_NOT_ALLOWED_CURSOR);
-#else
-    bd->MouseCursors[ImGuiMouseCursor_ResizeAll] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_ResizeNESW] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_ResizeNWSE] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-    bd->MouseCursors[ImGuiMouseCursor_NotAllowed] = glfwCreateStandardCursor(GLFW_ARROW_CURSOR);
-#endif
-    glfwSetErrorCallback(prev_error_callback);
-
-    // Chain GLFW callbacks: our callbacks will call the user's previously installed callbacks, if any.
-    if (install_callbacks)
-        ImGui_ImplGlfw_InstallCallbacks(window);
-
-    bd->ClientApi = client_api;
-    return true;
-}
-
-bool ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks)
-{
-    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_OpenGL);
-}
-
-bool ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks)
-{
-    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Vulkan);
-}
-
-bool ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks)
-{
-    return ImGui_ImplGlfw_Init(window, install_callbacks, GlfwClientApi_Unknown);
-}
-
-void ImGui_ImplGlfw_Shutdown()
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    IM_ASSERT(bd != NULL && "No platform backend to shutdown, or already shutdown?");
-    ImGuiIO& io = ImGui::GetIO();
-
-    if (bd->InstalledCallbacks)
-        ImGui_ImplGlfw_RestoreCallbacks(bd->Window);
-
-    for (ImGuiMouseCursor cursor_n = 0; cursor_n < ImGuiMouseCursor_COUNT; cursor_n++)
-        glfwDestroyCursor(bd->MouseCursors[cursor_n]);
-
-    io.BackendPlatformName = NULL;
-    io.BackendPlatformUserData = NULL;
-    IM_DELETE(bd);
-}
-
-static void ImGui_ImplGlfw_UpdateMouseData()
-{
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    ImGuiIO& io = ImGui::GetIO();
-
-#ifdef __EMSCRIPTEN__
-    const bool is_app_focused = true;
-#else
-    const bool is_app_focused = glfwGetWindowAttrib(bd->Window, GLFW_FOCUSED) != 0;
-#endif
-    if (is_app_focused)
-    {
-        // (Optional) Set OS mouse position from Dear ImGui if requested (rarely used, only when ImGuiConfigFlags_NavEnableSetMousePos is enabled by user)
-        if (io.WantSetMousePos)
-            glfwSetCursorPos(bd->Window, (double)io.MousePos.x, (double)io.MousePos.y);
-
-        // (Optional) Fallback to provide mouse position when focused (ImGui_ImplGlfw_CursorPosCallback already provides this when hovered or captured)
-        if (is_app_focused && bd->MouseWindow == NULL)
-        {
-            double mouse_x, mouse_y;
-            glfwGetCursorPos(bd->Window, &mouse_x, &mouse_y);
-            io.AddMousePosEvent((float)mouse_x, (float)mouse_y);
-            bd->LastValidMousePos = ImVec2((float)mouse_x, (float)mouse_y);
-        }
-    }
-}
-
-static void ImGui_ImplGlfw_UpdateMouseCursor()
-{
-    ImGuiIO& io = ImGui::GetIO();
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    if ((io.ConfigFlags & ImGuiConfigFlags_NoMouseCursorChange) || glfwGetInputMode(bd->Window, GLFW_CURSOR) == GLFW_CURSOR_DISABLED)
-        return;
-
-    ImGuiMouseCursor imgui_cursor = ImGui::GetMouseCursor();
-    if (imgui_cursor == ImGuiMouseCursor_None || io.MouseDrawCursor)
-    {
-        // Hide OS mouse cursor if imgui is drawing it or if it wants no cursor
-        glfwSetInputMode(bd->Window, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
-    }
-    else
-    {
-        // Show OS mouse cursor
-        // FIXME-PLATFORM: Unfocused windows seems to fail changing the mouse cursor with GLFW 3.2, but 3.3 works here.
-        glfwSetCursor(bd->Window, bd->MouseCursors[imgui_cursor] ? bd->MouseCursors[imgui_cursor] : bd->MouseCursors[ImGuiMouseCursor_Arrow]);
-        glfwSetInputMode(bd->Window, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
-    }
-}
-
-// Update gamepad inputs
-static inline float Saturate(float v) { return v < 0.0f ? 0.0f : v  > 1.0f ? 1.0f : v; }
-static void ImGui_ImplGlfw_UpdateGamepads()
-{
-    ImGuiIO& io = ImGui::GetIO();
-    if ((io.ConfigFlags & ImGuiConfigFlags_NavEnableGamepad) == 0)
-        return;
-
-    io.BackendFlags &= ~ImGuiBackendFlags_HasGamepad;
-#if GLFW_HAS_GAMEPAD_API
-    GLFWgamepadstate gamepad;
-    if (!glfwGetGamepadState(GLFW_JOYSTICK_1, &gamepad))
-        return;
-    #define MAP_BUTTON(KEY_NO, BUTTON_NO, _UNUSED)          do { io.AddKeyEvent(KEY_NO, gamepad.buttons[BUTTON_NO] != 0); } while (0)
-    #define MAP_ANALOG(KEY_NO, AXIS_NO, _UNUSED, V0, V1)    do { float v = gamepad.axes[AXIS_NO]; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
-#else
-    int axes_count = 0, buttons_count = 0;
-    const float* axes = glfwGetJoystickAxes(GLFW_JOYSTICK_1, &axes_count);
-    const unsigned char* buttons = glfwGetJoystickButtons(GLFW_JOYSTICK_1, &buttons_count);
-    if (axes_count == 0 || buttons_count == 0)
-        return;
-    #define MAP_BUTTON(KEY_NO, _UNUSED, BUTTON_NO)          do { io.AddKeyEvent(KEY_NO, (buttons_count > BUTTON_NO && buttons[BUTTON_NO] == GLFW_PRESS)); } while (0)
-    #define MAP_ANALOG(KEY_NO, _UNUSED, AXIS_NO, V0, V1)    do { float v = (axes_count > AXIS_NO) ? axes[AXIS_NO] : V0; v = (v - V0) / (V1 - V0); io.AddKeyAnalogEvent(KEY_NO, v > 0.10f, Saturate(v)); } while (0)
-#endif
-    io.BackendFlags |= ImGuiBackendFlags_HasGamepad;
-    MAP_BUTTON(ImGuiKey_GamepadStart,       GLFW_GAMEPAD_BUTTON_START,          7);
-    MAP_BUTTON(ImGuiKey_GamepadBack,        GLFW_GAMEPAD_BUTTON_BACK,           6);
-    MAP_BUTTON(ImGuiKey_GamepadFaceDown,    GLFW_GAMEPAD_BUTTON_A,              0);     // Xbox A, PS Cross
-    MAP_BUTTON(ImGuiKey_GamepadFaceRight,   GLFW_GAMEPAD_BUTTON_B,              1);     // Xbox B, PS Circle
-    MAP_BUTTON(ImGuiKey_GamepadFaceLeft,    GLFW_GAMEPAD_BUTTON_X,              2);     // Xbox X, PS Square
-    MAP_BUTTON(ImGuiKey_GamepadFaceUp,      GLFW_GAMEPAD_BUTTON_Y,              3);     // Xbox Y, PS Triangle
-    MAP_BUTTON(ImGuiKey_GamepadDpadLeft,    GLFW_GAMEPAD_BUTTON_DPAD_LEFT,      13);
-    MAP_BUTTON(ImGuiKey_GamepadDpadRight,   GLFW_GAMEPAD_BUTTON_DPAD_RIGHT,     11);
-    MAP_BUTTON(ImGuiKey_GamepadDpadUp,      GLFW_GAMEPAD_BUTTON_DPAD_UP,        10);
-    MAP_BUTTON(ImGuiKey_GamepadDpadDown,    GLFW_GAMEPAD_BUTTON_DPAD_DOWN,      12);
-    MAP_BUTTON(ImGuiKey_GamepadL1,          GLFW_GAMEPAD_BUTTON_LEFT_BUMPER,    4);
-    MAP_BUTTON(ImGuiKey_GamepadR1,          GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER,   5);
-    MAP_ANALOG(ImGuiKey_GamepadL2,          GLFW_GAMEPAD_AXIS_LEFT_TRIGGER,     4,      -0.75f,  +1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadR2,          GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER,    5,      -0.75f,  +1.0f);
-    MAP_BUTTON(ImGuiKey_GamepadL3,          GLFW_GAMEPAD_BUTTON_LEFT_THUMB,     8);
-    MAP_BUTTON(ImGuiKey_GamepadR3,          GLFW_GAMEPAD_BUTTON_RIGHT_THUMB,    9);
-    MAP_ANALOG(ImGuiKey_GamepadLStickLeft,  GLFW_GAMEPAD_AXIS_LEFT_X,           0,      -0.25f,  -1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadLStickRight, GLFW_GAMEPAD_AXIS_LEFT_X,           0,      +0.25f,  +1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadLStickUp,    GLFW_GAMEPAD_AXIS_LEFT_Y,           1,      -0.25f,  -1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadLStickDown,  GLFW_GAMEPAD_AXIS_LEFT_Y,           1,      +0.25f,  +1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadRStickLeft,  GLFW_GAMEPAD_AXIS_RIGHT_X,          2,      -0.25f,  -1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadRStickRight, GLFW_GAMEPAD_AXIS_RIGHT_X,          2,      +0.25f,  +1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadRStickUp,    GLFW_GAMEPAD_AXIS_RIGHT_Y,          3,      -0.25f,  -1.0f);
-    MAP_ANALOG(ImGuiKey_GamepadRStickDown,  GLFW_GAMEPAD_AXIS_RIGHT_Y,          3,      +0.25f,  +1.0f);
-    #undef MAP_BUTTON
-    #undef MAP_ANALOG
-}
-
-void ImGui_ImplGlfw_NewFrame()
-{
-    ImGuiIO& io = ImGui::GetIO();
-    ImGui_ImplGlfw_Data* bd = ImGui_ImplGlfw_GetBackendData();
-    IM_ASSERT(bd != NULL && "Did you call ImGui_ImplGlfw_InitForXXX()?");
-
-    // Setup display size (every frame to accommodate for window resizing)
-    int w, h;
-    int display_w, display_h;
-    glfwGetWindowSize(bd->Window, &w, &h);
-    glfwGetFramebufferSize(bd->Window, &display_w, &display_h);
-    io.DisplaySize = ImVec2((float)w, (float)h);
-    if (w > 0 && h > 0)
-        io.DisplayFramebufferScale = ImVec2((float)display_w / (float)w, (float)display_h / (float)h);
-
-    // Setup time step
-    double current_time = glfwGetTime();
-    io.DeltaTime = bd->Time > 0.0 ? (float)(current_time - bd->Time) : (float)(1.0f / 60.0f);
-    bd->Time = current_time;
-
-    ImGui_ImplGlfw_UpdateMouseData();
-    ImGui_ImplGlfw_UpdateMouseCursor();
-
-    // Update game controllers (if enabled and available)
-    ImGui_ImplGlfw_UpdateGamepads();
-}
-
-#if defined(__clang__)
-#pragma clang diagnostic pop
-#endif

ImguiBase/imgui/headers/imconfig.h

@@ -1,124 +0,0 @@
-//-----------------------------------------------------------------------------
-// COMPILE-TIME OPTIONS FOR DEAR IMGUI
-// Runtime options (clipboard callbacks, enabling various features, etc.) can generally be set via the ImGuiIO structure.
-// You can use ImGui::SetAllocatorFunctions() before calling ImGui::CreateContext() to rewire memory allocation functions.
-//-----------------------------------------------------------------------------
-// A) You may edit imconfig.h (and not overwrite it when updating Dear ImGui, or maintain a patch/rebased branch with your modifications to it)
-// B) or '#define IMGUI_USER_CONFIG "my_imgui_config.h"' in your project and then add directives in your own file without touching this template.
-//-----------------------------------------------------------------------------
-// You need to make sure that configuration settings are defined consistently _everywhere_ Dear ImGui is used, which include the imgui*.cpp
-// files but also _any_ of your code that uses Dear ImGui. This is because some compile-time options have an affect on data structures.
-// Defining those options in imconfig.h will ensure every compilation unit gets to see the same data structure layouts.
-// Call IMGUI_CHECKVERSION() from your .cpp files to verify that the data structures your files are using are matching the ones imgui.cpp is using.
-//-----------------------------------------------------------------------------
-
-#pragma once
-
-//---- Define assertion handler. Defaults to calling assert().
-// If your macro uses multiple statements, make sure is enclosed in a 'do { .. } while (0)' block so it can be used as a single statement.
-//#define IM_ASSERT(_EXPR)  MyAssert(_EXPR)
-//#define IM_ASSERT(_EXPR)  ((void)(_EXPR))     // Disable asserts
-
-//---- Define attributes of all API symbols declarations, e.g. for DLL under Windows
-// Using Dear ImGui via a shared library is not recommended, because of function call overhead and because we don't guarantee backward nor forward ABI compatibility.
-// DLL users: heaps and globals are not shared across DLL boundaries! You will need to call SetCurrentContext() + SetAllocatorFunctions()
-// for each static/DLL boundary you are calling from. Read "Context and Memory Allocators" section of imgui.cpp for more details.
-//#define IMGUI_API __declspec( dllexport )
-//#define IMGUI_API __declspec( dllimport )
-
-//---- Don't define obsolete functions/enums/behaviors. Consider enabling from time to time after updating to avoid using soon-to-be obsolete function/names.
-//#define IMGUI_DISABLE_OBSOLETE_FUNCTIONS
-//#define IMGUI_DISABLE_OBSOLETE_KEYIO                      // 1.87: disable legacy io.KeyMap[]+io.KeysDown[] in favor io.AddKeyEvent(). This will be folded into IMGUI_DISABLE_OBSOLETE_FUNCTIONS in a few versions.
-
-//---- Disable all of Dear ImGui or don't implement standard windows.
-// It is very strongly recommended to NOT disable the demo windows during development. Please read comments in imgui_demo.cpp.
-//#define IMGUI_DISABLE                                     // Disable everything: all headers and source files will be empty.
-//#define IMGUI_DISABLE_DEMO_WINDOWS                        // Disable demo windows: ShowDemoWindow()/ShowStyleEditor() will be empty. Not recommended.
-//#define IMGUI_DISABLE_METRICS_WINDOW                      // Disable metrics/debugger and other debug tools: ShowMetricsWindow() and ShowStackToolWindow() will be empty.
-
-//---- Don't implement some functions to reduce linkage requirements.
-//#define IMGUI_DISABLE_WIN32_DEFAULT_CLIPBOARD_FUNCTIONS   // [Win32] Don't implement default clipboard handler. Won't use and link with OpenClipboard/GetClipboardData/CloseClipboard etc. (user32.lib/.a, kernel32.lib/.a)
-//#define IMGUI_ENABLE_WIN32_DEFAULT_IME_FUNCTIONS          // [Win32] [Default with Visual Studio] Implement default IME handler (require imm32.lib/.a, auto-link for Visual Studio, -limm32 on command-line for MinGW)
-//#define IMGUI_DISABLE_WIN32_DEFAULT_IME_FUNCTIONS         // [Win32] [Default with non-Visual Studio compilers] Don't implement default IME handler (won't require imm32.lib/.a)
-//#define IMGUI_DISABLE_WIN32_FUNCTIONS                     // [Win32] Won't use and link with any Win32 function (clipboard, ime).
-//#define IMGUI_ENABLE_OSX_DEFAULT_CLIPBOARD_FUNCTIONS      // [OSX] Implement default OSX clipboard handler (need to link with '-framework ApplicationServices', this is why this is not the default).
-//#define IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS            // Don't implement ImFormatString/ImFormatStringV so you can implement them yourself (e.g. if you don't want to link with vsnprintf)
-//#define IMGUI_DISABLE_DEFAULT_MATH_FUNCTIONS              // Don't implement ImFabs/ImSqrt/ImPow/ImFmod/ImCos/ImSin/ImAcos/ImAtan2 so you can implement them yourself.
-//#define IMGUI_DISABLE_FILE_FUNCTIONS                      // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle at all (replace them with dummies)
-//#define IMGUI_DISABLE_DEFAULT_FILE_FUNCTIONS              // Don't implement ImFileOpen/ImFileClose/ImFileRead/ImFileWrite and ImFileHandle so you can implement them yourself if you don't want to link with fopen/fclose/fread/fwrite. This will also disable the LogToTTY() function.
-//#define IMGUI_DISABLE_DEFAULT_ALLOCATORS                  // Don't implement default allocators calling malloc()/free() to avoid linking with them. You will need to call ImGui::SetAllocatorFunctions().
-//#define IMGUI_DISABLE_SSE                                 // Disable use of SSE intrinsics even if available
-
-//---- Include imgui_user.h at the end of imgui.h as a convenience
-//#define IMGUI_INCLUDE_IMGUI_USER_H
-
-//---- Pack colors to BGRA8 instead of RGBA8 (to avoid converting from one to another)
-//#define IMGUI_USE_BGRA_PACKED_COLOR
-
-//---- Use 32-bit for ImWchar (default is 16-bit) to support unicode planes 1-16. (e.g. point beyond 0xFFFF like emoticons, dingbats, symbols, shapes, ancient languages, etc...)
-//#define IMGUI_USE_WCHAR32
-
-//---- Avoid multiple STB libraries implementations, or redefine path/filenames to prioritize another version
-// By default the embedded implementations are declared static and not available outside of Dear ImGui sources files.
-//#define IMGUI_STB_TRUETYPE_FILENAME   "my_folder/stb_truetype.h"
-//#define IMGUI_STB_RECT_PACK_FILENAME  "my_folder/stb_rect_pack.h"
-//#define IMGUI_DISABLE_STB_TRUETYPE_IMPLEMENTATION
-//#define IMGUI_DISABLE_STB_RECT_PACK_IMPLEMENTATION
-
-//---- Use stb_printf's faster implementation of vsnprintf instead of the one from libc (unless IMGUI_DISABLE_DEFAULT_FORMAT_FUNCTIONS is defined)
-// Requires 'stb_sprintf.h' to be available in the include path. Compatibility checks of arguments and formats done by clang and GCC will be disabled in order to support the extra formats provided by STB sprintf.
-// #define IMGUI_USE_STB_SPRINTF
-
-//---- Use FreeType to build and rasterize the font atlas (instead of stb_truetype which is embedded by default in Dear ImGui)
-// Requires FreeType headers to be available in the include path. Requires program to be compiled with 'misc/freetype/imgui_freetype.cpp' (in this repository) + the FreeType library (not provided).
-// On Windows you may use vcpkg with 'vcpkg install freetype --triplet=x64-windows' + 'vcpkg integrate install'.
-//#define IMGUI_ENABLE_FREETYPE
-
-//---- Use stb_truetype to build and rasterize the font atlas (default)
-// The only purpose of this define is if you want force compilation of the stb_truetype backend ALONG with the FreeType backend.
-//#define IMGUI_ENABLE_STB_TRUETYPE
-
-//---- Define constructor and implicit cast operators to convert back<>forth between your math types and ImVec2/ImVec4.
-// This will be inlined as part of ImVec2 and ImVec4 class declarations.
-/*
-#define IM_VEC2_CLASS_EXTRA                                                 \
-        ImVec2(const MyVec2& f) { x = f.x; y = f.y; }                       \
-        operator MyVec2() const { return MyVec2(x,y); }
-
-#define IM_VEC4_CLASS_EXTRA                                                 \
-        ImVec4(const MyVec4& f) { x = f.x; y = f.y; z = f.z; w = f.w; }     \
-        operator MyVec4() const { return MyVec4(x,y,z,w); }
-*/
-
-//---- Use 32-bit vertex indices (default is 16-bit) is one way to allow large meshes with more than 64K vertices.
-// Your renderer backend will need to support it (most example renderer backends support both 16/32-bit indices).
-// Another way to allow large meshes while keeping 16-bit indices is to handle ImDrawCmd::VtxOffset in your renderer.
-// Read about ImGuiBackendFlags_RendererHasVtxOffset for details.
-//#define ImDrawIdx unsigned int
-
-//---- Override ImDrawCallback signature (will need to modify renderer backends accordingly)
-//struct ImDrawList;
-//struct ImDrawCmd;
-//typedef void (*MyImDrawCallback)(const ImDrawList* draw_list, const ImDrawCmd* cmd, void* my_renderer_user_data);
-//#define ImDrawCallback MyImDrawCallback
-
-//---- Debug Tools: Macro to break in Debugger
-// (use 'Metrics->Tools->Item Picker' to pick widgets with the mouse and break into them for easy debugging.)
-//#define IM_DEBUG_BREAK  IM_ASSERT(0)
-//#define IM_DEBUG_BREAK  __debugbreak()
-
-//---- Debug Tools: Have the Item Picker break in the ItemAdd() function instead of ItemHoverable(),
-// (which comes earlier in the code, will catch a few extra items, allow picking items other than Hovered one.)
-// This adds a small runtime cost which is why it is not enabled by default.
-//#define IMGUI_DEBUG_TOOL_ITEM_PICKER_EX
-
-//---- Debug Tools: Enable slower asserts
-//#define IMGUI_DEBUG_PARANOID
-
-//---- Tip: You can add extra functions within the ImGui:: namespace, here or in your own headers files.
-/*
-namespace ImGui
-{
-    void MyFunction(const char* name, const MyMatrix44& v);
-}
-*/

ImguiBase/imgui/headers/imgui_impl_glfw.h

@@ -1,46 +0,0 @@
-// dear imgui: Platform Backend for GLFW
-// This needs to be used along with a Renderer (e.g. OpenGL3, Vulkan, WebGPU..)
-// (Info: GLFW is a cross-platform general purpose library for handling windows, inputs, OpenGL/Vulkan graphics context creation, etc.)
-
-// Implemented features:
-//  [X] Platform: Clipboard support.
-//  [X] Platform: Keyboard support. Since 1.87 we are using the io.AddKeyEvent() function. Pass ImGuiKey values to all key functions e.g. ImGui::IsKeyPressed(ImGuiKey_Space). [Legacy GLFW_KEY_* values will also be supported unless IMGUI_DISABLE_OBSOLETE_KEYIO is set]
-//  [X] Platform: Gamepad support. Enable with 'io.ConfigFlags |= ImGuiConfigFlags_NavEnableGamepad'.
-//  [X] Platform: Mouse cursor shape and visibility. Disable with 'io.ConfigFlags |= ImGuiConfigFlags_NoMouseCursorChange' (note: the resizing cursors requires GLFW 3.4+).
-
-// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
-// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
-// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
-// Read online: https://github.com/ocornut/imgui/tree/master/docs
-
-// About GLSL version:
-// The 'glsl_version' initialization parameter defaults to "#version 150" if NULL.
-// Only override if your GL version doesn't handle this GLSL version. Keep NULL if unsure!
-
-#pragma once
-#include "imgui.h"      // IMGUI_IMPL_API
-
-struct GLFWwindow;
-struct GLFWmonitor;
-
-IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOpenGL(GLFWwindow* window, bool install_callbacks);
-IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForVulkan(GLFWwindow* window, bool install_callbacks);
-IMGUI_IMPL_API bool     ImGui_ImplGlfw_InitForOther(GLFWwindow* window, bool install_callbacks);
-IMGUI_IMPL_API void     ImGui_ImplGlfw_Shutdown();
-IMGUI_IMPL_API void     ImGui_ImplGlfw_NewFrame();
-
-// GLFW callbacks (installer)
-// - When calling Init with 'install_callbacks=true': ImGui_ImplGlfw_InstallCallbacks() is called. GLFW callbacks will be installed for you. They will chain-call user's previously installed callbacks, if any.
-// - When calling Init with 'install_callbacks=false': GLFW callbacks won't be installed. You will need to call individual function yourself from your own GLFW callbacks.
-IMGUI_IMPL_API void     ImGui_ImplGlfw_InstallCallbacks(GLFWwindow* window);
-IMGUI_IMPL_API void     ImGui_ImplGlfw_RestoreCallbacks(GLFWwindow* window);
-
-// GLFW callbacks (individual callbacks to call if you didn't install callbacks)
-IMGUI_IMPL_API void     ImGui_ImplGlfw_WindowFocusCallback(GLFWwindow* window, int focused);        // Since 1.84
-IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorEnterCallback(GLFWwindow* window, int entered);        // Since 1.84
-IMGUI_IMPL_API void     ImGui_ImplGlfw_CursorPosCallback(GLFWwindow* window, double x, double y);   // Since 1.87
-IMGUI_IMPL_API void     ImGui_ImplGlfw_MouseButtonCallback(GLFWwindow* window, int button, int action, int mods);
-IMGUI_IMPL_API void     ImGui_ImplGlfw_ScrollCallback(GLFWwindow* window, double xoffset, double yoffset);
-IMGUI_IMPL_API void     ImGui_ImplGlfw_KeyCallback(GLFWwindow* window, int key, int scancode, int action, int mods);
-IMGUI_IMPL_API void     ImGui_ImplGlfw_CharCallback(GLFWwindow* window, unsigned int c);
-IMGUI_IMPL_API void     ImGui_ImplGlfw_MonitorCallback(GLFWmonitor* monitor, int event);

ImguiBase/imgui/headers/imgui_impl_vulkan.h

@@ -1,155 +0,0 @@
-// dear imgui: Renderer Backend for Vulkan
-// This needs to be used along with a Platform Backend (e.g. GLFW, SDL, Win32, custom..)
-
-// Implemented features:
-//  [X] Renderer: Support for large meshes (64k+ vertices) with 16-bit indices.
-//  [!] Renderer: User texture binding. Use 'VkDescriptorSet' as ImTextureID. Read the FAQ about ImTextureID! See https://github.com/ocornut/imgui/pull/914 for discussions.
-
-// Important: on 32-bit systems, user texture binding is only supported if your imconfig file has '#define ImTextureID ImU64'.
-// See imgui_impl_vulkan.cpp file for details.
-
-// You can use unmodified imgui_impl_* files in your project. See examples/ folder for examples of using this.
-// Prefer including the entire imgui/ repository into your project (either as a copy or as a submodule), and only build the backends you need.
-// If you are new to Dear ImGui, read documentation from the docs/ folder + read the top of imgui.cpp.
-// Read online: https://github.com/ocornut/imgui/tree/master/docs
-
-// The aim of imgui_impl_vulkan.h/.cpp is to be usable in your engine without any modification.
-// IF YOU FEEL YOU NEED TO MAKE ANY CHANGE TO THIS CODE, please share them and your feedback at https://github.com/ocornut/imgui/
-
-// Important note to the reader who wish to integrate imgui_impl_vulkan.cpp/.h in their own engine/app.
-// - Common ImGui_ImplVulkan_XXX functions and structures are used to interface with imgui_impl_vulkan.cpp/.h.
-//   You will use those if you want to use this rendering backend in your engine/app.
-// - Helper ImGui_ImplVulkanH_XXX functions and structures are only used by this example (main.cpp) and by
-//   the backend itself (imgui_impl_vulkan.cpp), but should PROBABLY NOT be used by your own engine/app code.
-// Read comments in imgui_impl_vulkan.h.
-
-#pragma once
-#include "imgui.h"      // IMGUI_IMPL_API
-
-// [Configuration] in order to use a custom Vulkan function loader:
-// (1) You'll need to disable default Vulkan function prototypes.
-//     We provide a '#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES' convenience configuration flag.
-//     In order to make sure this is visible from the imgui_impl_vulkan.cpp compilation unit:
-//     - Add '#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES' in your imconfig.h file
-//     - Or as a compilation flag in your build system
-//     - Or uncomment here (not recommended because you'd be modifying imgui sources!)
-//     - Do not simply add it in a .cpp file!
-// (2) Call ImGui_ImplVulkan_LoadFunctions() before ImGui_ImplVulkan_Init() with your custom function.
-// If you have no idea what this is, leave it alone!
-//#define IMGUI_IMPL_VULKAN_NO_PROTOTYPES
-
-// Vulkan includes
-#if defined(IMGUI_IMPL_VULKAN_NO_PROTOTYPES) && !defined(VK_NO_PROTOTYPES)
-#define VK_NO_PROTOTYPES
-#endif
-#include <vulkan/vulkan.h>
-
-// Initialization data, for ImGui_ImplVulkan_Init()
-// [Please zero-clear before use!]
-struct ImGui_ImplVulkan_InitInfo
-{
-    VkInstance                      Instance;
-    VkPhysicalDevice                PhysicalDevice;
-    VkDevice                        Device;
-    uint32_t                        QueueFamily;
-    VkQueue                         Queue;
-    VkPipelineCache                 PipelineCache;
-    VkDescriptorPool                DescriptorPool;
-    uint32_t                        Subpass;
-    uint32_t                        MinImageCount;          // >= 2
-    uint32_t                        ImageCount;             // >= MinImageCount
-    VkSampleCountFlagBits           MSAASamples;            // >= VK_SAMPLE_COUNT_1_BIT (0 -> default to VK_SAMPLE_COUNT_1_BIT)
-    const VkAllocationCallbacks*    Allocator;
-    void                            (*CheckVkResultFn)(VkResult err);
-};
-
-// Called by user code
-IMGUI_IMPL_API bool         ImGui_ImplVulkan_Init(ImGui_ImplVulkan_InitInfo* info, VkRenderPass render_pass);
-IMGUI_IMPL_API void         ImGui_ImplVulkan_Shutdown();
-IMGUI_IMPL_API void         ImGui_ImplVulkan_NewFrame();
-IMGUI_IMPL_API void         ImGui_ImplVulkan_RenderDrawData(ImDrawData* draw_data, VkCommandBuffer command_buffer, VkPipeline pipeline = VK_NULL_HANDLE);
-IMGUI_IMPL_API bool         ImGui_ImplVulkan_CreateFontsTexture(VkCommandBuffer command_buffer);
-IMGUI_IMPL_API void         ImGui_ImplVulkan_DestroyFontUploadObjects();
-IMGUI_IMPL_API void         ImGui_ImplVulkan_SetMinImageCount(uint32_t min_image_count); // To override MinImageCount after initialization (e.g. if swap chain is recreated)
-
-// Register a texture (VkDescriptorSet == ImTextureID)
-// FIXME: This is experimental in the sense that we are unsure how to best design/tackle this problem, please post to https://github.com/ocornut/imgui/pull/914 if you have suggestions.
-IMGUI_IMPL_API VkDescriptorSet ImGui_ImplVulkan_AddTexture(VkSampler sampler, VkImageView image_view, VkImageLayout image_layout);
-
-// Optional: load Vulkan functions with a custom function loader
-// This is only useful with IMGUI_IMPL_VULKAN_NO_PROTOTYPES / VK_NO_PROTOTYPES
-IMGUI_IMPL_API bool         ImGui_ImplVulkan_LoadFunctions(PFN_vkVoidFunction(*loader_func)(const char* function_name, void* user_data), void* user_data = NULL);
-
-//-------------------------------------------------------------------------
-// Internal / Miscellaneous Vulkan Helpers
-// (Used by example's main.cpp. Used by multi-viewport features. PROBABLY NOT used by your own engine/app.)
-//-------------------------------------------------------------------------
-// You probably do NOT need to use or care about those functions.
-// Those functions only exist because:
-//   1) they facilitate the readability and maintenance of the multiple main.cpp examples files.
-//   2) the upcoming multi-viewport feature will need them internally.
-// Generally we avoid exposing any kind of superfluous high-level helpers in the backends,
-// but it is too much code to duplicate everywhere so we exceptionally expose them.
-//
-// Your engine/app will likely _already_ have code to setup all that stuff (swap chain, render pass, frame buffers, etc.).
-// You may read this code to learn about Vulkan, but it is recommended you use you own custom tailored code to do equivalent work.
-// (The ImGui_ImplVulkanH_XXX functions do not interact with any of the state used by the regular ImGui_ImplVulkan_XXX functions)
-//-------------------------------------------------------------------------
-
-struct ImGui_ImplVulkanH_Frame;
-struct ImGui_ImplVulkanH_Window;
-
-// Helpers
-IMGUI_IMPL_API void                 ImGui_ImplVulkanH_CreateOrResizeWindow(VkInstance instance, VkPhysicalDevice physical_device, VkDevice device, ImGui_ImplVulkanH_Window* wnd, uint32_t queue_family, const VkAllocationCallbacks* allocator, int w, int h, uint32_t min_image_count);
-IMGUI_IMPL_API void                 ImGui_ImplVulkanH_DestroyWindow(VkInstance instance, VkDevice device, ImGui_ImplVulkanH_Window* wnd, const VkAllocationCallbacks* allocator);
-IMGUI_IMPL_API VkSurfaceFormatKHR   ImGui_ImplVulkanH_SelectSurfaceFormat(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkFormat* request_formats, int request_formats_count, VkColorSpaceKHR request_color_space);
-IMGUI_IMPL_API VkPresentModeKHR     ImGui_ImplVulkanH_SelectPresentMode(VkPhysicalDevice physical_device, VkSurfaceKHR surface, const VkPresentModeKHR* request_modes, int request_modes_count);
-IMGUI_IMPL_API int                  ImGui_ImplVulkanH_GetMinImageCountFromPresentMode(VkPresentModeKHR present_mode);
-
-// Helper structure to hold the data needed by one rendering frame
-// (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)
-// [Please zero-clear before use!]
-struct ImGui_ImplVulkanH_Frame
-{
-    VkCommandPool       CommandPool;
-    VkCommandBuffer     CommandBuffer;
-    VkFence             Fence;
-    VkImage             Backbuffer;
-    VkImageView         BackbufferView;
-    VkFramebuffer       Framebuffer;
-};
-
-struct ImGui_ImplVulkanH_FrameSemaphores
-{
-    VkSemaphore         ImageAcquiredSemaphore;
-    VkSemaphore         RenderCompleteSemaphore;
-};
-
-// Helper structure to hold the data needed by one rendering context into one OS window
-// (Used by example's main.cpp. Used by multi-viewport features. Probably NOT used by your own engine/app.)
-struct ImGui_ImplVulkanH_Window
-{
-    int                 Width;
-    int                 Height;
-    VkSwapchainKHR      Swapchain;
-    VkSurfaceKHR        Surface;
-    VkSurfaceFormatKHR  SurfaceFormat;
-    VkPresentModeKHR    PresentMode;
-    VkRenderPass        RenderPass;
-    VkPipeline          Pipeline;               // The window pipeline may uses a different VkRenderPass than the one passed in ImGui_ImplVulkan_InitInfo
-    bool                ClearEnable;
-    VkClearValue        ClearValue;
-    uint32_t            FrameIndex;             // Current frame being rendered to (0 <= FrameIndex < FrameInFlightCount)
-    uint32_t            ImageCount;             // Number of simultaneous in-flight frames (returned by vkGetSwapchainImagesKHR, usually derived from min_image_count)
-    uint32_t            SemaphoreIndex;         // Current set of swapchain wait semaphores we're using (needs to be distinct from per frame data)
-    ImGui_ImplVulkanH_Frame*            Frames;
-    ImGui_ImplVulkanH_FrameSemaphores*  FrameSemaphores;
-
-    ImGui_ImplVulkanH_Window()
-    {
-        memset(this, 0, sizeof(*this));
-        PresentMode = VK_PRESENT_MODE_MAX_ENUM_KHR;
-        ClearEnable = true;
-    }
-};
-

ImguiBase/imgui/headers/imstb_rectpack.h

@@ -1,639 +0,0 @@
-// [DEAR IMGUI]
-// This is a slightly modified version of stb_rect_pack.h 1.00.
-// Those changes would need to be pushed into nothings/stb:
-// - Added STBRP__CDECL
-// Grep for [DEAR IMGUI] to find the changes.
-
-// stb_rect_pack.h - v1.00 - public domain - rectangle packing
-// Sean Barrett 2014
-//
-// Useful for e.g. packing rectangular textures into an atlas.
-// Does not do rotation.
-//
-// Not necessarily the awesomest packing method, but better than
-// the totally naive one in stb_truetype (which is primarily what
-// this is meant to replace).
-//
-// Has only had a few tests run, may have issues.
-//
-// More docs to come.
-//
-// No memory allocations; uses qsort() and assert() from stdlib.
-// Can override those by defining STBRP_SORT and STBRP_ASSERT.
-//
-// This library currently uses the Skyline Bottom-Left algorithm.
-//
-// Please note: better rectangle packers are welcome! Please
-// implement them to the same API, but with a different init
-// function.
-//
-// Credits
-//
-//  Library
-//    Sean Barrett
-//  Minor features
-//    Martins Mozeiko
-//    github:IntellectualKitty
-//
-//  Bugfixes / warning fixes
-//    Jeremy Jaussaud
-//    Fabian Giesen
-//
-// Version history:
-//
-//     1.00  (2019-02-25)  avoid small space waste; gracefully fail too-wide rectangles
-//     0.99  (2019-02-07)  warning fixes
-//     0.11  (2017-03-03)  return packing success/fail result
-//     0.10  (2016-10-25)  remove cast-away-const to avoid warnings
-//     0.09  (2016-08-27)  fix compiler warnings
-//     0.08  (2015-09-13)  really fix bug with empty rects (w=0 or h=0)
-//     0.07  (2015-09-13)  fix bug with empty rects (w=0 or h=0)
-//     0.06  (2015-04-15)  added STBRP_SORT to allow replacing qsort
-//     0.05:  added STBRP_ASSERT to allow replacing assert
-//     0.04:  fixed minor bug in STBRP_LARGE_RECTS support
-//     0.01:  initial release
-//
-// LICENSE
-//
-//   See end of file for license information.
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//       INCLUDE SECTION
-//
-
-#ifndef STB_INCLUDE_STB_RECT_PACK_H
-#define STB_INCLUDE_STB_RECT_PACK_H
-
-#define STB_RECT_PACK_VERSION  1
-
-#ifdef STBRP_STATIC
-#define STBRP_DEF static
-#else
-#define STBRP_DEF extern
-#endif
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-typedef struct stbrp_context stbrp_context;
-typedef struct stbrp_node    stbrp_node;
-typedef struct stbrp_rect    stbrp_rect;
-
-#ifdef STBRP_LARGE_RECTS
-typedef int            stbrp_coord;
-#else
-typedef unsigned short stbrp_coord;
-#endif
-
-STBRP_DEF int stbrp_pack_rects (stbrp_context *context, stbrp_rect *rects, int num_rects);
-// Assign packed locations to rectangles. The rectangles are of type
-// 'stbrp_rect' defined below, stored in the array 'rects', and there
-// are 'num_rects' many of them.
-//
-// Rectangles which are successfully packed have the 'was_packed' flag
-// set to a non-zero value and 'x' and 'y' store the minimum location
-// on each axis (i.e. bottom-left in cartesian coordinates, top-left
-// if you imagine y increasing downwards). Rectangles which do not fit
-// have the 'was_packed' flag set to 0.
-//
-// You should not try to access the 'rects' array from another thread
-// while this function is running, as the function temporarily reorders
-// the array while it executes.
-//
-// To pack into another rectangle, you need to call stbrp_init_target
-// again. To continue packing into the same rectangle, you can call
-// this function again. Calling this multiple times with multiple rect
-// arrays will probably produce worse packing results than calling it
-// a single time with the full rectangle array, but the option is
-// available.
-//
-// The function returns 1 if all of the rectangles were successfully
-// packed and 0 otherwise.
-
-struct stbrp_rect
-{
-   // reserved for your use:
-   int            id;
-
-   // input:
-   stbrp_coord    w, h;
-
-   // output:
-   stbrp_coord    x, y;
-   int            was_packed;  // non-zero if valid packing
-
-}; // 16 bytes, nominally
-
-
-STBRP_DEF void stbrp_init_target (stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes);
-// Initialize a rectangle packer to:
-//    pack a rectangle that is 'width' by 'height' in dimensions
-//    using temporary storage provided by the array 'nodes', which is 'num_nodes' long
-//
-// You must call this function every time you start packing into a new target.
-//
-// There is no "shutdown" function. The 'nodes' memory must stay valid for
-// the following stbrp_pack_rects() call (or calls), but can be freed after
-// the call (or calls) finish.
-//
-// Note: to guarantee best results, either:
-//       1. make sure 'num_nodes' >= 'width'
-//   or  2. call stbrp_allow_out_of_mem() defined below with 'allow_out_of_mem = 1'
-//
-// If you don't do either of the above things, widths will be quantized to multiples
-// of small integers to guarantee the algorithm doesn't run out of temporary storage.
-//
-// If you do #2, then the non-quantized algorithm will be used, but the algorithm
-// may run out of temporary storage and be unable to pack some rectangles.
-
-STBRP_DEF void stbrp_setup_allow_out_of_mem (stbrp_context *context, int allow_out_of_mem);
-// Optionally call this function after init but before doing any packing to
-// change the handling of the out-of-temp-memory scenario, described above.
-// If you call init again, this will be reset to the default (false).
-
-
-STBRP_DEF void stbrp_setup_heuristic (stbrp_context *context, int heuristic);
-// Optionally select which packing heuristic the library should use. Different
-// heuristics will produce better/worse results for different data sets.
-// If you call init again, this will be reset to the default.
-
-enum
-{
-   STBRP_HEURISTIC_Skyline_default=0,
-   STBRP_HEURISTIC_Skyline_BL_sortHeight = STBRP_HEURISTIC_Skyline_default,
-   STBRP_HEURISTIC_Skyline_BF_sortHeight
-};
-
-
-//////////////////////////////////////////////////////////////////////////////
-//
-// the details of the following structures don't matter to you, but they must
-// be visible so you can handle the memory allocations for them
-
-struct stbrp_node
-{
-   stbrp_coord  x,y;
-   stbrp_node  *next;
-};
-
-struct stbrp_context
-{
-   int width;
-   int height;
-   int align;
-   int init_mode;
-   int heuristic;
-   int num_nodes;
-   stbrp_node *active_head;
-   stbrp_node *free_head;
-   stbrp_node extra[2]; // we allocate two extra nodes so optimal user-node-count is 'width' not 'width+2'
-};
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-
-//////////////////////////////////////////////////////////////////////////////
-//
-//     IMPLEMENTATION SECTION
-//
-
-#ifdef STB_RECT_PACK_IMPLEMENTATION
-#ifndef STBRP_SORT
-#include <stdlib.h>
-#define STBRP_SORT qsort
-#endif
-
-#ifndef STBRP_ASSERT
-#include <assert.h>
-#define STBRP_ASSERT assert
-#endif
-
-// [DEAR IMGUI] Added STBRP__CDECL
-#ifdef _MSC_VER
-#define STBRP__NOTUSED(v)  (void)(v)
-#define STBRP__CDECL __cdecl
-#else
-#define STBRP__NOTUSED(v)  (void)sizeof(v)
-#define STBRP__CDECL
-#endif
-
-enum
-{
-   STBRP__INIT_skyline = 1
-};
-
-STBRP_DEF void stbrp_setup_heuristic(stbrp_context *context, int heuristic)
-{
-   switch (context->init_mode) {
-      case STBRP__INIT_skyline:
-         STBRP_ASSERT(heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight || heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight);
-         context->heuristic = heuristic;
-         break;
-      default:
-         STBRP_ASSERT(0);
-   }
-}
-
-STBRP_DEF void stbrp_setup_allow_out_of_mem(stbrp_context *context, int allow_out_of_mem)
-{
-   if (allow_out_of_mem)
-      // if it's ok to run out of memory, then don't bother aligning them;
-      // this gives better packing, but may fail due to OOM (even though
-      // the rectangles easily fit). @TODO a smarter approach would be to only
-      // quantize once we've hit OOM, then we could get rid of this parameter.
-      context->align = 1;
-   else {
-      // if it's not ok to run out of memory, then quantize the widths
-      // so that num_nodes is always enough nodes.
-      //
-      // I.e. num_nodes * align >= width
-      //                  align >= width / num_nodes
-      //                  align = ceil(width/num_nodes)
-
-      context->align = (context->width + context->num_nodes-1) / context->num_nodes;
-   }
-}
-
-STBRP_DEF void stbrp_init_target(stbrp_context *context, int width, int height, stbrp_node *nodes, int num_nodes)
-{
-   int i;
-#ifndef STBRP_LARGE_RECTS
-   STBRP_ASSERT(width <= 0xffff && height <= 0xffff);
-#endif
-
-   for (i=0; i < num_nodes-1; ++i)
-      nodes[i].next = &nodes[i+1];
-   nodes[i].next = NULL;
-   context->init_mode = STBRP__INIT_skyline;
-   context->heuristic = STBRP_HEURISTIC_Skyline_default;
-   context->free_head = &nodes[0];
-   context->active_head = &context->extra[0];
-   context->width = width;
-   context->height = height;
-   context->num_nodes = num_nodes;
-   stbrp_setup_allow_out_of_mem(context, 0);
-
-   // node 0 is the full width, node 1 is the sentinel (lets us not store width explicitly)
-   context->extra[0].x = 0;
-   context->extra[0].y = 0;
-   context->extra[0].next = &context->extra[1];
-   context->extra[1].x = (stbrp_coord) width;
-#ifdef STBRP_LARGE_RECTS
-   context->extra[1].y = (1<<30);
-#else
-   context->extra[1].y = 65535;
-#endif
-   context->extra[1].next = NULL;
-}
-
-// find minimum y position if it starts at x1
-static int stbrp__skyline_find_min_y(stbrp_context *c, stbrp_node *first, int x0, int width, int *pwaste)
-{
-   stbrp_node *node = first;
-   int x1 = x0 + width;
-   int min_y, visited_width, waste_area;
-
-   STBRP__NOTUSED(c);
-
-   STBRP_ASSERT(first->x <= x0);
-
-   #if 0
-   // skip in case we're past the node
-   while (node->next->x <= x0)
-      ++node;
-   #else
-   STBRP_ASSERT(node->next->x > x0); // we ended up handling this in the caller for efficiency
-   #endif
-
-   STBRP_ASSERT(node->x <= x0);
-
-   min_y = 0;
-   waste_area = 0;
-   visited_width = 0;
-   while (node->x < x1) {
-      if (node->y > min_y) {
-         // raise min_y higher.
-         // we've accounted for all waste up to min_y,
-         // but we'll now add more waste for everything we've visted
-         waste_area += visited_width * (node->y - min_y);
-         min_y = node->y;
-         // the first time through, visited_width might be reduced
-         if (node->x < x0)
-            visited_width += node->next->x - x0;
-         else
-            visited_width += node->next->x - node->x;
-      } else {
-         // add waste area
-         int under_width = node->next->x - node->x;
-         if (under_width + visited_width > width)
-            under_width = width - visited_width;
-         waste_area += under_width * (min_y - node->y);
-         visited_width += under_width;
-      }
-      node = node->next;
-   }
-
-   *pwaste = waste_area;
-   return min_y;
-}
-
-typedef struct
-{
-   int x,y;
-   stbrp_node **prev_link;
-} stbrp__findresult;
-
-static stbrp__findresult stbrp__skyline_find_best_pos(stbrp_context *c, int width, int height)
-{
-   int best_waste = (1<<30), best_x, best_y = (1 << 30);
-   stbrp__findresult fr;
-   stbrp_node **prev, *node, *tail, **best = NULL;
-
-   // align to multiple of c->align
-   width = (width + c->align - 1);
-   width -= width % c->align;
-   STBRP_ASSERT(width % c->align == 0);
-
-   // if it can't possibly fit, bail immediately
-   if (width > c->width || height > c->height) {
-      fr.prev_link = NULL;
-      fr.x = fr.y = 0;
-      return fr;
-   }
-
-   node = c->active_head;
-   prev = &c->active_head;
-   while (node->x + width <= c->width) {
-      int y,waste;
-      y = stbrp__skyline_find_min_y(c, node, node->x, width, &waste);
-      if (c->heuristic == STBRP_HEURISTIC_Skyline_BL_sortHeight) { // actually just want to test BL
-         // bottom left
-         if (y < best_y) {
-            best_y = y;
-            best = prev;
-         }
-      } else {
-         // best-fit
-         if (y + height <= c->height) {
-            // can only use it if it first vertically
-            if (y < best_y || (y == best_y && waste < best_waste)) {
-               best_y = y;
-               best_waste = waste;
-               best = prev;
-            }
-         }
-      }
-      prev = &node->next;
-      node = node->next;
-   }
-
-   best_x = (best == NULL) ? 0 : (*best)->x;
-
-   // if doing best-fit (BF), we also have to try aligning right edge to each node position
-   //
-   // e.g, if fitting
-   //
-   //     ____________________
-   //    |____________________|
-   //
-   //            into
-   //
-   //   |                         |
-   //   |             ____________|
-   //   |____________|
-   //
-   // then right-aligned reduces waste, but bottom-left BL is always chooses left-aligned
-   //
-   // This makes BF take about 2x the time
-
-   if (c->heuristic == STBRP_HEURISTIC_Skyline_BF_sortHeight) {
-      tail = c->active_head;
-      node = c->active_head;
-      prev = &c->active_head;
-      // find first node that's admissible
-      while (tail->x < width)
-         tail = tail->next;
-      while (tail) {
-         int xpos = tail->x - width;
-         int y,waste;
-         STBRP_ASSERT(xpos >= 0);
-         // find the left position that matches this
-         while (node->next->x <= xpos) {
-            prev = &node->next;
-            node = node->next;
-         }
-         STBRP_ASSERT(node->next->x > xpos && node->x <= xpos);
-         y = stbrp__skyline_find_min_y(c, node, xpos, width, &waste);
-         if (y + height <= c->height) {
-            if (y <= best_y) {
-               if (y < best_y || waste < best_waste || (waste==best_waste && xpos < best_x)) {
-                  best_x = xpos;
-                  STBRP_ASSERT(y <= best_y);
-                  best_y = y;
-                  best_waste = waste;
-                  best = prev;
-               }
-            }
-         }
-         tail = tail->next;
-      }
-   }
-
-   fr.prev_link = best;
-   fr.x = best_x;
-   fr.y = best_y;
-   return fr;
-}
-
-static stbrp__findresult stbrp__skyline_pack_rectangle(stbrp_context *context, int width, int height)
-{
-   // find best position according to heuristic
-   stbrp__findresult res = stbrp__skyline_find_best_pos(context, width, height);
-   stbrp_node *node, *cur;
-
-   // bail if:
-   //    1. it failed
-   //    2. the best node doesn't fit (we don't always check this)
-   //    3. we're out of memory
-   if (res.prev_link == NULL || res.y + height > context->height || context->free_head == NULL) {
-      res.prev_link = NULL;
-      return res;
-   }
-
-   // on success, create new node
-   node = context->free_head;
-   node->x = (stbrp_coord) res.x;
-   node->y = (stbrp_coord) (res.y + height);
-
-   context->free_head = node->next;
-
-   // insert the new node into the right starting point, and
-   // let 'cur' point to the remaining nodes needing to be
-   // stiched back in
-
-   cur = *res.prev_link;
-   if (cur->x < res.x) {
-      // preserve the existing one, so start testing with the next one
-      stbrp_node *next = cur->next;
-      cur->next = node;
-      cur = next;
-   } else {
-      *res.prev_link = node;
-   }
-
-   // from here, traverse cur and free the nodes, until we get to one
-   // that shouldn't be freed
-   while (cur->next && cur->next->x <= res.x + width) {
-      stbrp_node *next = cur->next;
-      // move the current node to the free list
-      cur->next = context->free_head;
-      context->free_head = cur;
-      cur = next;
-   }
-
-   // stitch the list back in
-   node->next = cur;
-
-   if (cur->x < res.x + width)
-      cur->x = (stbrp_coord) (res.x + width);
-
-#ifdef _DEBUG
-   cur = context->active_head;
-   while (cur->x < context->width) {
-      STBRP_ASSERT(cur->x < cur->next->x);
-      cur = cur->next;
-   }
-   STBRP_ASSERT(cur->next == NULL);
-
-   {
-      int count=0;
-      cur = context->active_head;
-      while (cur) {
-         cur = cur->next;
-         ++count;
-      }
-      cur = context->free_head;
-      while (cur) {
-         cur = cur->next;
-         ++count;
-      }
-      STBRP_ASSERT(count == context->num_nodes+2);
-   }
-#endif
-
-   return res;
-}
-
-// [DEAR IMGUI] Added STBRP__CDECL
-static int STBRP__CDECL rect_height_compare(const void *a, const void *b)
-{
-   const stbrp_rect *p = (const stbrp_rect *) a;
-   const stbrp_rect *q = (const stbrp_rect *) b;
-   if (p->h > q->h)
-      return -1;
-   if (p->h < q->h)
-      return  1;
-   return (p->w > q->w) ? -1 : (p->w < q->w);
-}
-
-// [DEAR IMGUI] Added STBRP__CDECL
-static int STBRP__CDECL rect_original_order(const void *a, const void *b)
-{
-   const stbrp_rect *p = (const stbrp_rect *) a;
-   const stbrp_rect *q = (const stbrp_rect *) b;
-   return (p->was_packed < q->was_packed) ? -1 : (p->was_packed > q->was_packed);
-}
-
-#ifdef STBRP_LARGE_RECTS
-#define STBRP__MAXVAL  0xffffffff
-#else
-#define STBRP__MAXVAL  0xffff
-#endif
-
-STBRP_DEF int stbrp_pack_rects(stbrp_context *context, stbrp_rect *rects, int num_rects)
-{
-   int i, all_rects_packed = 1;
-
-   // we use the 'was_packed' field internally to allow sorting/unsorting
-   for (i=0; i < num_rects; ++i) {
-      rects[i].was_packed = i;
-   }
-
-   // sort according to heuristic
-   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_height_compare);
-
-   for (i=0; i < num_rects; ++i) {
-      if (rects[i].w == 0 || rects[i].h == 0) {
-         rects[i].x = rects[i].y = 0;  // empty rect needs no space
-      } else {
-         stbrp__findresult fr = stbrp__skyline_pack_rectangle(context, rects[i].w, rects[i].h);
-         if (fr.prev_link) {
-            rects[i].x = (stbrp_coord) fr.x;
-            rects[i].y = (stbrp_coord) fr.y;
-         } else {
-            rects[i].x = rects[i].y = STBRP__MAXVAL;
-         }
-      }
-   }
-
-   // unsort
-   STBRP_SORT(rects, num_rects, sizeof(rects[0]), rect_original_order);
-
-   // set was_packed flags and all_rects_packed status
-   for (i=0; i < num_rects; ++i) {
-      rects[i].was_packed = !(rects[i].x == STBRP__MAXVAL && rects[i].y == STBRP__MAXVAL);
-      if (!rects[i].was_packed)
-         all_rects_packed = 0;
-   }
-
-   // return the all_rects_packed status
-   return all_rects_packed;
-}
-#endif
-
-/*
-------------------------------------------------------------------------------
-This software is available under 2 licenses -- choose whichever you prefer.
-------------------------------------------------------------------------------
-ALTERNATIVE A - MIT License
-Copyright (c) 2017 Sean Barrett
-Permission is hereby granted, free of charge, to any person obtaining a copy of
-this software and associated documentation files (the "Software"), to deal in
-the Software without restriction, including without limitation the rights to
-use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies
-of the Software, and to permit persons to whom the Software is furnished to do
-so, subject to the following conditions:
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-------------------------------------------------------------------------------
-ALTERNATIVE B - Public Domain (www.unlicense.org)
-This is free and unencumbered software released into the public domain.
-Anyone is free to copy, modify, publish, use, compile, sell, or distribute this
-software, either in source code form or as a compiled binary, for any purpose,
-commercial or non-commercial, and by any means.
-In jurisdictions that recognize copyright laws, the author or authors of this
-software dedicate any and all copyright interest in the software to the public
-domain. We make this dedication for the benefit of the public at large and to
-the detriment of our heirs and successors. We intend this dedication to be an
-overt act of relinquishment in perpetuity of all present and future rights to
-this software under copyright law.
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN
-ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
-WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-------------------------------------------------------------------------------
-*/

ImguiBase/vcpkg.json

@@ -0,0 +1,12 @@
+{
+  "$schema": "https://raw.githubusercontent.com/microsoft/vcpkg-tool/main/docs/vcpkg.schema.json",
+  "dependencies": [
+    "vulkan",
+    "vulkan-headers",
+    "glfw3",
+    {
+      "name": "imgui",
+      "features": [ "glfw-binding", "vulkan-binding" ]
+    }
+  ]
+}

ImguiNodes/ImguiNodes.cpp

@@ -1,297 +0,0 @@
-//Disables console window
-#if !_DEBUG
-#pragma comment(linker, "/SUBSYSTEM:windows /ENTRY:mainCRTStartup")
-#endif
-
-#include <iostream>
-#include <algorithm>
-#include "ImguiBase.h"
-#include "ImguiNodes.h"
-
-int main()
-{
-	ApplicationData applicationData{};
-
-	startImgui(&applicationData, init, draw, "Node Test", 1280, 720);
-}
-
-/// <summary>
-/// Setup before first draw.
-/// </summary>
-void init(DrawData& drawData, void* customData)
-{
-	ImGuiIO& io = ImGui::GetIO();
-	io.Fonts->AddFontFromFileTTF("Montserrat-Regular.ttf", 16.0f);
-}
-
-/// <summary>
-/// Draw main application content.
-/// </summary>
-void draw(DrawData& drawData, void* customData)
-{
-	ApplicationData* applicationData = static_cast<ApplicationData*>(customData);
-
-	// Top menu bar
-	ImGui::BeginMainMenuBar();
-	if (ImGui::Button("Add Node"))
-	{
-		std::string name{ "Node " };
-		name.append(std::to_string(applicationData->nodes.size() + 1));
-		applicationData->nodes.push_back(NodeWindow(name));
-	}
-	ImGui::EndMainMenuBar();
-
-	// Draw all node windows
-	bool isDraggingLine = false;
-	ImVec2 lineStartPos = ImVec2{};
-
-	auto nodeIterator = applicationData->nodes.begin();
-	while (nodeIterator != applicationData->nodes.end())
-	{
-		NodeWindow& node = *nodeIterator;
-
-		bool nodeOpen;
-		ImGui::Begin(node.title.c_str(), &nodeOpen, ImGuiWindowFlags_NoResize | ImGuiWindowFlags_AlwaysAutoResize);
-		{
-			if (!nodeOpen)
-			{
-				cleanEreaseNodeElements(*nodeIterator, applicationData);
-				nodeIterator = applicationData->nodes.erase(nodeIterator);
-				ImGui::End();
-				break; // TODO: contine creates bug with closing too many windows???
-			}
-
-			auto alertIterator = node.alerts.begin();
-			while (alertIterator != node.alerts.end())
-			{
-				ImGui::Text(alertIterator->name.c_str());
-				if (ImGui::IsWindowHovered() || ImGui::IsWindowFocused())
-				{
-					if (inlineButton("x", alertIterator._Ptr))
-					{
-						alertIterator = cleanEraseElement(node.alerts, alertIterator, applicationData);
-						continue;
-					}
-				}
-				else
-				{
-					invisibleInlineButton("x", "x");
-				}
-
-				ImGui::SameLine();
-				drawCircle(&alertIterator->position);
-
-				float lineHeight = ImGui::GetTextLineHeight();
-				ImVec2 dragAreaSize = ImVec2{ lineHeight, lineHeight };
-				invisibleDragArea(alertIterator._Ptr, dragAreaSize);
-				if (ImGui::BeginDragDropSource())
-				{
-					isDraggingLine = true;
-					lineStartPos = alertIterator->position;
-					ImGui::Text(alertIterator->name.c_str());
-
-					ConnectionPayload payload{ alertIterator->id };
-
-					ImGui::SetDragDropPayload("NODE_CONNECTION", (void*)&payload, sizeof(ConnectionPayload));
-					ImGui::EndDragDropSource();
-				}
-
-				alertIterator++;
-			}
-
-			auto triggerIterator = node.triggers.begin();
-			while (triggerIterator != node.triggers.end())
-			{
-				drawCircle(&triggerIterator->position);
-
-				float lineHeight = ImGui::GetTextLineHeight();
-				ImVec2 dragAreaSize = ImVec2{ lineHeight, lineHeight };
-				invisibleDragArea(triggerIterator._Ptr, dragAreaSize);
-				if (ImGui::BeginDragDropTarget())
-				{
-					if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload("NODE_CONNECTION"))
-					{
-						ConnectionPayload* payloadData = static_cast<ConnectionPayload*>(payload->Data);
-						applicationData->addConnection(payloadData->sourceID, triggerIterator->id);
-					}
-					ImGui::EndDragDropTarget();
-				}
-
-				ImGui::SameLine();
-				ImGui::Text(triggerIterator->name.c_str());
-				if (ImGui::IsWindowHovered() || ImGui::IsWindowFocused())
-				{
-					if (inlineButton("x", triggerIterator._Ptr))
-					{
-						triggerIterator = cleanEraseElement(node.triggers, triggerIterator, applicationData);
-						continue;
-					}
-				}
-				triggerIterator++;
-			}
-
-			if (ImGui::Button("New Alert"))
-			{
-				node.alerts.push_back(NodeElement("Today, 18:00"));
-			}
-			if (ImGui::Button("New Trigger"))
-			{
-				node.triggers.push_back(NodeElement("Doot"));
-			}
-		}
-		ImGui::End();
-
-		nodeIterator++;
-	}
-
-	// Draw drag line in foreground
-	if (isDraggingLine)
-	{
-		ImDrawList* drawList = ImGui::GetForegroundDrawList();
-		drawList->AddLine(lineStartPos, ImGui::GetMousePos(), IM_COL32(200, 200, 200, 255), 3.0f);
-	}
-
-	// Draw connected lines in background
-	ImDrawList* bgDrawList = ImGui::GetBackgroundDrawList();
-	for (NodeConnection& nodeConnection : applicationData->connections)
-	{
-		ImVec2 sourcePos = ImVec2{ 0, 0 };
-		ImVec2 targetPos = ImVec2{ 0, 0 };
-		for (auto node : applicationData->nodes)
-		{
-			for (auto alert : node.alerts)
-			{
-				if (alert.id == nodeConnection.sourceID)
-				{
-					targetPos = alert.position;
-				}
-			}
-			for (auto trigger : node.triggers)
-			{
-				if (trigger.id == nodeConnection.targetID)
-				{
-					sourcePos = trigger.position;
-				}
-			}
-		}
-		bgDrawList->AddLine(sourcePos, targetPos, IM_COL32_WHITE, 2.0f);
-	}
-}
-
-/// <summary>
-/// Creates an invisible button that does nothing, but can be used for drag/drop operations.
-/// </summary>
-void invisibleDragArea(const void* id, ImVec2& size)
-{
-	ImGui::PushID(id);
-	ImGui::InvisibleButton("", size);
-	ImGui::PopID();
-}
-
-/// <summary>
-/// Draws a small circle at the current cursor position.
-/// </summary>
-/// <param name="outCircleCenter">Returns the center position of the circle.</param>
-void drawCircle(ImVec2* outCircleCenter = nullptr)
-{
-	float lineHeight = ImGui::GetTextLineHeight();
-	float circleRadius = (lineHeight / 2.) * 0.75;
-	float circleOffset = lineHeight / 2.;
-
-	ImVec2 cursor = ImGui::GetCursorScreenPos();
-	ImVec2 circlePos = ImVec2{ cursor.x + circleOffset, cursor.y + circleOffset };
-
-	ImDrawList* drawList = ImGui::GetWindowDrawList();
-	drawList->AddCircleFilled(circlePos, circleRadius, IM_COL32_WHITE);
-
-	if (outCircleCenter != nullptr)
-	{
-		*outCircleCenter = circlePos;
-	}
-}
-
-/// <summary>
-/// Draws a small button in the same row.
-/// </summary>
-bool inlineButton(const char* title, const void* id)
-{
-	ImGui::SameLine();
-	ImGui::PushID(id);
-
-	bool result = ImGui::SmallButton(title);
-
-	ImGui::PopID();
-	return result;
-}
-
-bool invisibleInlineButton(const char* title, const char* id)
-{
-	ImGui::SameLine();
-	ImVec2 padding = ImGui::GetStyle().FramePadding;
-	ImVec2 size = ImGui::CalcTextSize(title);
-	size.x += padding.x * 2.;
-	return ImGui::InvisibleButton(id, size);
-}
-
-/// <summary>
-/// Removes any attached connections before erasing this NodeElement from a vector.
-/// </summary>
-/// <returns>Continued iterator</returns>
-std::vector<NodeElement>::iterator cleanEraseElement(std::vector<NodeElement>& elements, std::vector<NodeElement>::iterator toErase, ApplicationData* data)
-{
-	auto connectionIterator = data->connections.begin();
-	while (connectionIterator != data->connections.end())
-	{
-		if (connectionIterator->sourceID == toErase->id || connectionIterator->targetID == toErase->id)
-		{
-			connectionIterator = data->connections.erase(connectionIterator);
-			continue;
-		}
-		connectionIterator++;
-	}
-	return elements.erase(toErase);
-}
-
-void cleanEreaseNodeElements(NodeWindow& node, ApplicationData* data)
-{
-	auto triggerIterator = node.triggers.begin();
-	while (triggerIterator != node.triggers.end())
-	{
-		triggerIterator = cleanEraseElement(node.triggers, triggerIterator, data);
-	}
-	auto alertIterator = node.alerts.begin();
-	while (alertIterator != node.alerts.end())
-	{
-		alertIterator = cleanEraseElement(node.alerts, alertIterator, data);
-	}
-}
-
-NodeElement::NodeElement(std::string name) : name(name)
-{
-	this->id = globalNodeIdCounter;
-	globalNodeIdCounter++;
-}
-
-NodeWindow::NodeWindow(std::string title) : title(title)
-{
-}
-
-void ApplicationData::addConnection(int sourceID, int targetID)
-{
-	// Remove duplicate connections
-	auto connectionIterator = connections.begin();
-	while (connectionIterator != connections.end())
-	{
-		// Currently only remove on exact match, maybe add some other constraints later
-		if (connectionIterator->sourceID == sourceID && connectionIterator->targetID == targetID)
-		{
-			connectionIterator = connections.erase(connectionIterator);
-			continue;
-		}
-
-		connectionIterator++;
-	}
-
-	// Add new connection
-	connections.push_back(NodeConnection{ sourceID, targetID });
-}

ImguiNodes/ImguiNodes.h

@@ -1,57 +0,0 @@
-#pragma once
-#include <string>
-#include <vector>
-
-int globalNodeIdCounter = 0;
-
-class NodeElement {
-public:
-	int id = -1;
-	std::string name = {};
-	ImVec2 position = {};
-
-	NodeElement(std::string name);
-};
-
-class NodeWindow {
-public:
-	std::string title = {};
-	std::vector<NodeElement> alerts = {};
-	std::vector<NodeElement> triggers = {};
-
-	NodeWindow(std::string title);
-};
-
-struct NodeConnection {
-	int sourceID = -1;
-	int targetID = -1;
-};
-
-struct ConnectionPayload {
-	int sourceID = -1;
-};
-
-class ApplicationData {
-public:
-	std::vector<NodeWindow> nodes = {};
-	std::vector<NodeConnection> connections = {};
-
-	void addConnection(int sourceID, int targetID);
-};
-
-enum class CircleDragType
-{
-	None,
-	Source,
-	Target
-};
-
-void init(DrawData& drawData, void* customData);
-void draw(DrawData& drawData, void* customDataVoid);
-
-void invisibleDragArea(const void* id, ImVec2& size);
-void drawCircle(ImVec2* outCircleCenter);
-bool inlineButton(const char* title, const void* id);
-bool invisibleInlineButton(const char* title, const char* id);
-std::vector<NodeElement>::iterator cleanEraseElement(std::vector<NodeElement>& vector, std::vector<NodeElement>::iterator toErase, ApplicationData* data);
-void cleanEreaseNodeElements(NodeWindow& node, ApplicationData* data);

ImguiNodes/ImguiNodes.vcxproj

@@ -1,159 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project DefaultTargets="Build" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup Label="ProjectConfigurations">
-    <ProjectConfiguration Include="Debug|Win32">
-      <Configuration>Debug</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|Win32">
-      <Configuration>Release</Configuration>
-      <Platform>Win32</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Debug|x64">
-      <Configuration>Debug</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-    <ProjectConfiguration Include="Release|x64">
-      <Configuration>Release</Configuration>
-      <Platform>x64</Platform>
-    </ProjectConfiguration>
-  </ItemGroup>
-  <PropertyGroup Label="Globals">
-    <VCProjectVersion>16.0</VCProjectVersion>
-    <Keyword>Win32Proj</Keyword>
-    <ProjectGuid>{be4e5cfb-c93f-41d7-b474-721ad43d51a3}</ProjectGuid>
-    <RootNamespace>ImguiNodes</RootNamespace>
-    <WindowsTargetPlatformVersion>10.0</WindowsTargetPlatformVersion>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>true</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">
-    <ConfigurationType>Application</ConfigurationType>
-    <UseDebugLibraries>false</UseDebugLibraries>
-    <PlatformToolset>v143</PlatformToolset>
-    <WholeProgramOptimization>true</WholeProgramOptimization>
-    <CharacterSet>Unicode</CharacterSet>
-  </PropertyGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />
-  <ImportGroup Label="ExtensionSettings">
-  </ImportGroup>
-  <ImportGroup Label="Shared">
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />
-  </ImportGroup>
-  <PropertyGroup Label="UserMacros" />
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>E:\Code\AsuroImgui\ImguiBase;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>E:\Code\AsuroImgui\ImguiBase;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <LinkIncremental>true</LinkIncremental>
-    <IncludePath>E:\Code\AsuroImgui\ImguiBase;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <LinkIncremental>false</LinkIncremental>
-    <IncludePath>E:\Code\AsuroImgui\ImguiBase;$(IncludePath)</IncludePath>
-  </PropertyGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>WIN32;NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>_DEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">
-    <ClCompile>
-      <WarningLevel>Level3</WarningLevel>
-      <FunctionLevelLinking>true</FunctionLevelLinking>
-      <IntrinsicFunctions>true</IntrinsicFunctions>
-      <SDLCheck>true</SDLCheck>
-      <PreprocessorDefinitions>NDEBUG;_CONSOLE;%(PreprocessorDefinitions)</PreprocessorDefinitions>
-      <ConformanceMode>true</ConformanceMode>
-    </ClCompile>
-    <Link>
-      <SubSystem>Console</SubSystem>
-      <EnableCOMDATFolding>true</EnableCOMDATFolding>
-      <OptimizeReferences>true</OptimizeReferences>
-      <GenerateDebugInformation>true</GenerateDebugInformation>
-    </Link>
-  </ItemDefinitionGroup>
-  <ItemGroup>
-    <ClCompile Include="ImguiNodes.cpp" />
-  </ItemGroup>
-  <ItemGroup>
-    <ProjectReference Include="..\ImguiBase\ImguiBase.vcxproj">
-      <Project>{bb8a1ca3-7660-49e9-baf1-a99f733f7db6}</Project>
-    </ProjectReference>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="ImguiNodes.h" />
-  </ItemGroup>
-  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />
-  <ImportGroup Label="ExtensionTargets">
-  </ImportGroup>
-</Project>

ImguiNodes/ImguiNodes.vcxproj.filters

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="utf-8"?>
-<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">
-  <ItemGroup>
-    <Filter Include="Source Files">
-      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>
-      <Extensions>cpp;c;cc;cxx;c++;cppm;ixx;def;odl;idl;hpj;bat;asm;asmx</Extensions>
-    </Filter>
-    <Filter Include="Header Files">
-      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>
-      <Extensions>h;hh;hpp;hxx;h++;hm;inl;inc;ipp;xsd</Extensions>
-    </Filter>
-    <Filter Include="Resource Files">
-      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>
-      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>
-    </Filter>
-  </ItemGroup>
-  <ItemGroup>
-    <ClCompile Include="ImguiNodes.cpp">
-      <Filter>Source Files</Filter>
-    </ClCompile>
-  </ItemGroup>
-  <ItemGroup>
-    <ClInclude Include="ImguiNodes.h">
-      <Filter>Header Files</Filter>
-    </ClInclude>
-  </ItemGroup>
-</Project>