sfltplug.cpp

#include "sfltplug.h"

#include "imgui.h"
#include "imgui_impl_opengl3.h"
#include "imgui_impl_win32.h"
#include "imgui_internal.h"
#include "imgui-knobs.h"
#include "imgui_stdlib.h"

#include "tinyfiledialogs.h"

#include <GL/GL.h>
#include <ranges>
#include <array>

#include <Shlwapi.h>

#define SFLT_RENAMESRC_SOUNDFONT 1
#define SFLT_RENAMESRC_PRESET 2

// currently loaded soundfonts, shared across all SFLT instances
static lockable<std::unordered_map<std::filesystem::path, std::shared_ptr<sfhi::SoundFontSynth>>> SOUNDFONTS;

const char* SFLT_ASCII = 
	"     _____ _____ __  _______  \n"
	"    / ___// ___// / /__  __/  \n"
	"   / /__ / /__ / /    / /     \n"
	"  /__  // ___// /    / /      \n"
	" ___/ // /   / /___ / /       \n"
	"/____//_/   /_____//_/          "
	;

const char* VERSION_STRING = "BETA v0.4.1";


const std::array<const char*, 14> MOTDS = {
	"it's pronounced \"svelte\".",
	"trans rights? i prefer trans wrongs. go apeshit",
	"I'M CHORDING OUT !!",
	"I Can't Believe It's Not Fruity SoundFont Player!",
	"I'M SFLTING OUT !!",
	"it's pronounced \"ess-eff-ell-tee\".",
	"now with extra Mother 3.sf2!",
	"owo",
	"go ahead. use Earthbound.sf2 bank 0 patch 19.",
	"uwu",
	"check out chordioid.com!",
	"they're putting PRONOUNS in the soundfont players.",
	"i'd like a word with whoever wrote the SF2 spec.",
	"more like ash GAYLORD. OWNED.",
};


const std::array<const char*, 6> RESAMPLE_METHODS = {
	"linear",
	"hermite",
	"sinc16",
	"sinc32",
	"sinc64",
	"nearest",
};

const int PlugVersion = 6;	// used in SaveRestoreState

char SFLT_LongName[] = "SFLT (VC++)";
char SFLT_ShortName[] = "SFLT";

const unsigned PLUGIN_WIDTH = 370;
const unsigned PLUGIN_HEIGHT = 385;

// the information structure describing this plugin to the host
TFruityPlugInfo PlugInfo = {
	CurrentSDKVersion,
	SFLT_LongName,
	SFLT_ShortName,
	FPF_Type_FullGen | FPF_CanStealKBFocus | FPF_CanSend,
	NumParamsConst,
	32,                                 // default polyphony
	0                                   // no internal controllers
};

bool CreateDeviceWGL(HWND hWnd, HDC& data, HGLRC& g_hRC);
void CleanupDeviceWGL(HWND hWnd, HDC data);
void ResetDeviceWGL();

void SaveConfig();
std::string utf8_encode(const std::wstring& wstr);

int GetParamMaxValue(int param) {
	switch (param) {
	
	case Env2Attack:
	case Env2Decay:
	case Env2Release:
		return 5940;

	case Lfo2Delay:
		return 5900;

	case Lfo2Amount:
		return 256;

	case Modulation:
	case ReverbSendLvMult:
	case ChorusSendLvMult:
	case Lfo2Speed:
	case InitialFilterCutoff:
	case Env2Sustain:
	default:
		return 127;
	}
}

extern IMGUI_IMPL_API LRESULT ImGui_ImplWin32_WndProcHandler(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam);

ImVec4 ImColorFromBytes(BYTE r, BYTE g, BYTE b, BYTE a = 255) {
	return ImVec4((float)r / 255.f, (float)g / 255.f, (float)b / 255.f, (float)a / 255.f);
}

// translate linear velocity (0.0f..1.0f) to FL volume
float VelocityToFLVolume(float Velocity) {
	return (powf(10.f, Velocity * 1.33347107645f) - 1.f) / 10.f;
}

void SFLTPlug::UpdateSkin() {
	if (!ctx)
		return;

	auto& style = ImGui::GetStyle();

	int skin = 0;

	{
		auto lock = CONFIG.lock_read();
		skin = CONFIG.get().skin;
	}

	style = ImGuiStyle();

	switch (skin) {

	case 0: // default
		break;
	}
}

void SFLTPlug::ImGuiDragIntPost() {
	
	if (ImGui::IsItemActive())
		ImMouseWrap();
	
	// god this is such a clusterfuck
	SFLTPlug::ImGuiKnobPost();
}

void SFLTPlug::ImGuiKnobPost() {
	if (ImGui::IsItemDeactivated()) {
		ImRect bb = ImRect(ImGui::GetItemRectMin(), ImGui::GetItemRectMax());

		ImVec2 CursorPos = bb.GetCenter();

		POINT posScreen;
		posScreen.x = CursorPos.x;
		posScreen.y = CursorPos.y;

		if (::ClientToScreen(EditorHandle, &posScreen))
			::SetCursorPos(posScreen.x, posScreen.y);
	}
}

void SFLTPlug::ImMouseWrap() {
	ImGui::SetMouseCursor(ImGuiMouseCursor_None);

	POINT rawpos;
	POINT oldpos;
	POINT pos;

	if (::GetCursorPos(&rawpos)) {
		pos = rawpos;
		oldpos = rawpos;

		const long width = (long)PLUGIN_WIDTH;
		const long height = (long)PLUGIN_HEIGHT;

		if (::ScreenToClient(EditorHandle, &pos)) {

			if (pos.x < 0)
				rawpos.x += width;
			if (pos.y < 0)
				rawpos.y += height;
			if (pos.x > width)
				rawpos.x -= width;
			if (pos.y > height)
				rawpos.y -= height;

			if (oldpos.x != rawpos.x || oldpos.y != rawpos.y) {
				didJustTeleportX = oldpos.x != rawpos.x;
				didJustTeleportY = oldpos.y != rawpos.y;

				::SetCursorPos(rawpos.x, rawpos.y);
			}
		}
	}
}

void SFLTPlug::ImGuiParam(int param, int min, int max, float speed) {
	ImGui::SetItemUsingMouseWheel();

	if (ImGui::IsItemActive()) {
		editedParam = param;

		ImMouseWrap();
	}
	else if (ImGui::IsItemHovered()) {
		static char name[258];
		auto value = GetParamValueString(param, ParamValue[param]);

		name[0] = '^';
		name[1] = 'b';

		GetName(0, param, 0, (char*)name + 2);

		auto idx = strlen((const char*)name);

		name[idx++] = ':';
		name[idx++] = ' ';

		strcpy_s((char*)name + idx, 258 - idx, value.c_str());

		//ShowHintMsg(name);
		//hintShown = true;
		currentHint = name;

		if (ImGui::IsMouseReleased(ImGuiMouseButton_Right)) {
			Unlock();
			PlugHost->Dispatcher(HostTag, FHD_ShowStandardParamMenu, param, 0);
			Lock();
		}

		float wheel = ImGui::GetIO().MouseWheel;

		if (wheel) {
			if (speed == 0.0f) {
				speed = float(max - min) / 46.40625f;
			}

			if (ImGui::GetIO().KeyCtrl)
				speed /= 2.0f;

			ParamValue[param] = std::clamp(int(ParamValue[param] + wheel * speed), min, max);
			Unlock();
			PlugHost->OnParamChanged(HostTag, param, ParamValue[param]);
			Lock();
		}
	}
}

void _stdcall SFLTPlug::Idle_Public() {
	Lock();
	
	if (EditorHandle)
		RedrawWindow(EditorHandle, NULL, NULL, RDW_INTERNALPAINT);

	// check if threaded loading finished
	if (loadingFinished.load()) {
		currentFileExists = true;
		loadingFinished.store(false);
		LoadSoundFont(currentFile);
	}

	Unlock();
}


LRESULT CALLBACK PlgWndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam)
{
	// get plugin pointer
	SFLTPlug* plugin = (SFLTPlug*)GetWindowLongPtr(hwnd, GWLP_USERDATA);

	if (!plugin)
		return DefWindowProc(hwnd, message, wParam, lParam);

	//auto currentTime = std::chrono::system_clock::now();
	//auto elapsed = currentTime - plugin->lastUpdate;
	//auto millis = std::chrono::duration_cast<std::chrono::microseconds>(elapsed).count() / 1000.0;
	
	//if (millis > (1000.0 / 60.0)) {
	//	plugin->lastUpdate = currentTime;
	//}

	ImGui::SetCurrentContext(plugin->ctx);

	if (ImGui_ImplWin32_WndProcHandler(hwnd, message, wParam, lParam)) {
		return true;
	}

	// erase background message
	if (message == WM_ERASEBKGND)
	{
		return 0;
	}

	// paint message
	if (message == WM_PAINT)
	{
		plugin->Lock();
		
		if (plugin->imFrameActive) {
			plugin->Unlock();
			return 0;
		}
		
		plugin->imFrameActive = true;

		if (plugin->sfBrowserQueued) {
			plugin->sfBrowserQueued = false;

			static char const* patterns[] = { "*.sf2" };

			auto result = tinyfd_openFileDialog("Open SoundFont", plugin->browserDir.string().c_str(), 1, patterns, "SoundFont files", 0);

			if (result) {
				plugin->LoadSoundFont(result);
				plugin->UpdateName(SFLT_RENAMESRC_SOUNDFONT);
			}
		}
		
		bool saveConfig = false;

		if (plugin->dirBrowserQueued) {
			plugin->dirBrowserQueued = false;

			auto lock = CONFIG.lock_write();
			auto& path = CONFIG.get_mut().libraryPath;
			auto result = tinyfd_selectFolderDialog("Select default SoundFonts folder", path.c_str());

			if (result) {
				path = std::string(result);
				plugin->browserDir = path;
				// defer this bc of write lock
				saveConfig = true;
			}
		}

		if (saveConfig)
			SaveConfig();

		// start window paint
		PAINTSTRUCT ps;
		HDC const hdc = BeginPaint(hwnd, &ps);
		
		wglMakeCurrent(hdc, plugin->g_hRC);

		ImGui_ImplOpenGL3_NewFrame();
		ImGui_ImplWin32_NewFrame();
		ImGui::NewFrame();
		
		auto& io = ImGui::GetIO();
		auto& style = ImGui::GetStyle();
		
		if (plugin->didJustTeleportX) {
			if (io.MouseDelta.x < 0)
				io.MouseDelta.x += PLUGIN_WIDTH;
			else
				io.MouseDelta.x -= PLUGIN_WIDTH;

			plugin->didJustTeleportX = false;
		}

		if (plugin->didJustTeleportY) {
			if (io.MouseDelta.y < 0)
				io.MouseDelta.y += PLUGIN_HEIGHT;
			else
				io.MouseDelta.y -= PLUGIN_HEIGHT;

			plugin->didJustTeleportY = false;
		}
		
		
		style.ButtonTextAlign = ImVec2(0.0, 0.5);
		style.AntiAliasedFill = false;

		ImGui::SetNextWindowPos(ImVec2(0, 0));
		ImGui::SetNextWindowSize(io.DisplaySize);

		auto mainFlags = ImGuiWindowFlags_NoNav | ImGuiWindowFlags_NoMove;

		if (plugin->uiState == SFLTPlug::About) {
			mainFlags |= ImGuiWindowFlags_NoTitleBar | ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoCollapse;
		} else {
			mainFlags |= ImGuiWindowFlags_NoDecoration | ImGuiWindowFlags_NoScrollWithMouse;
			ImGui::SetNextWindowScroll(ImVec2(0.0, 0.0));
		}

		bool uiDirty = false;

		if (plugin->uiState != plugin->prevUiState) {
			uiDirty = true;
			plugin->prevUiState = plugin->uiState;
		}

		if (ImGui::Begin("SFLTWindow", nullptr, mainFlags)) {			
			char* lastHint = plugin->currentHint;

			plugin->currentHint = nullptr;
			plugin->overrideHintUpdate = false;

			switch (plugin->uiState) {

			case SFLTPlug::MainMenu: {
				if (uiDirty)
					plugin->UpdateKbFocus();

				if (ImGui::BeginChild("File", ImVec2(0, 63), ImGuiChildFlags_Border)) {
					const char* fileText = "(No SoundFont loaded)";
					
					if (plugin->loadingThreaded.load()) {
						int progress = plugin->threadProgress.load();
						
						plugin->threadProgresStrBuf = "Loading... " + std::to_string(int((float)progress / (float)plugin->threadFileSize * 100.0f)) + "%";
						
						fileText = plugin->threadProgresStrBuf.c_str();
					}
					else if (!plugin->currentFile.empty()) {
						if (plugin->currentFileExists) {
							auto slash = plugin->currentFile_u8.rfind('/');

							if (slash == std::string::npos)
								slash = plugin->currentFile_u8.rfind('\\');

							fileText = (const char*)plugin->currentFile_u8.c_str() + slash + 1;
						} else {
							static const char file_not_found[] = "(File missing)";
							fileText = &file_not_found[0];
						}
					}

					if (ImGui::Button(fileText, ImVec2(308, 0))) {
						if (!plugin->loadingThreaded.load()) {
							plugin->uiState = SFLTPlug::FileBrowser;
							memset(&plugin->pbFilter, 0, 64);
							plugin->filterDirty = true;
						}
					}
					
					if (ImGui::IsItemHovered()) {
						static char hint[] = "File browser";
						plugin->currentHint = hint;
					}

					ImGui::SameLine();

					if (ImGui::Button("..")) {
						if (!plugin->loadingThreaded.load()) {
							plugin->sfBrowserQueued = true;
						}
					}

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Use native file dialog";
						plugin->currentHint = hint;
					}


					ImGui::Separator();

					ImGui::SetCursorPosY(ImGui::GetCursorPosY() + 1);

					static WORD PATCHMIN = 0;
					static WORD PATCHMAX = 255;

					// naughty use of private ImGui slider flag
					const auto dragFlags = ImGuiSliderFlags_Vertical | ImGuiSliderFlags_NoInput;

					ImGui::SetNextItemWidth(32.0);

					if (ImGui::DragScalar("##Patch", ImGuiDataType_U16, (void*)&plugin->presetPatch, 0.2, (void*)&PATCHMIN, (void*)&PATCHMAX, "%d", dragFlags)) {
						plugin->UpdatePresetIdx();
						plugin->UpdateName(SFLT_RENAMESRC_PRESET);
					}
					
					plugin->ImGuiDragIntPost();

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Patch";
						plugin->currentHint = hint;

						float wheel = ImGui::GetIO().MouseWheel;

						if (wheel) {
							plugin->presetPatch = std::clamp(int(plugin->presetPatch + (wheel > 0 ? 1 : -1)), int(PATCHMIN), int(PATCHMAX));
							plugin->UpdatePresetIdx();
							plugin->UpdateName(SFLT_RENAMESRC_PRESET);
						}
					}
					
					ImGui::SameLine();

					ImGui::SetNextItemWidth(32.0);

					if (ImGui::DragScalar("##Bank", ImGuiDataType_U16, (void*)&plugin->presetBank, 0.2, (void*)&PATCHMIN, (void*)&PATCHMAX, "%d", dragFlags)) {
						plugin->UpdatePresetIdx();
						plugin->UpdateName(SFLT_RENAMESRC_PRESET);
					}
					
					plugin->ImGuiDragIntPost();

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Bank";
						plugin->currentHint = hint;

						float wheel = ImGui::GetIO().MouseWheel;

						if (wheel) {
							plugin->presetBank = std::clamp(int(plugin->presetBank + (wheel > 0 ? 1 : -1)), int(PATCHMIN), int(PATCHMAX));
							plugin->UpdatePresetIdx();
							plugin->UpdateName(SFLT_RENAMESRC_PRESET);
						}
					}

					ImGui::SameLine();

					const char* presetName = "(None)";

					bool presetDidExist = plugin->presetExists;

					if (plugin->presetExists) {
						auto& patch = plugin->soundFont->presets[plugin->presetIdx];
						presetName = &patch.presetName[0];
					}
					else {
						ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(0.7, 0.75, 0.8, 1.0));
					}

					if (ImGui::Button(presetName, ImVec2(ImGui::GetContentRegionAvail().x, 0))) {
						if (plugin->soundFont) {
							plugin->uiState = SFLTPlug::PresetBrowser;
							memset(&plugin->pbFilter, 0, 64);
							plugin->filterDirty = true;
						}
					}

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Preset browser";
						plugin->currentHint = hint;

						ImGui::SetItemUsingMouseWheel();
						float wheel = ImGui::GetIO().MouseWheel;

						if (!plugin->presetScrollList.empty()) {
							if (wheel) {
								size_t newIdx = plugin->presetIdx;

								if (wheel < 0) {
									plugin->presetScrollIdx += 1;

									if (plugin->presetScrollIdx >= plugin->presetScrollList.size())
										plugin->presetScrollIdx = 0;

									newIdx = plugin->presetScrollList[plugin->presetScrollIdx];
								}

								else { // wheel > 0
									if (plugin->presetScrollIdx == 0)
										plugin->presetScrollIdx = plugin->presetScrollList.size() - 1;
									else
										plugin->presetScrollIdx -= 1;

									newIdx = plugin->presetScrollList[plugin->presetScrollIdx];
								}

								if (newIdx != plugin->presetIdx) {
									plugin->presetBank = plugin->soundFont->presets[newIdx].bank;
									plugin->presetPatch = plugin->soundFont->presets[newIdx].preset;
									plugin->UpdatePresetIdx();
									plugin->UpdateName(SFLT_RENAMESRC_PRESET);
								}
							}
						}
					}

					if (!presetDidExist) {
						ImGui::PopStyleColor();
					}
					
				}
				ImGui::EndChild();

				plugin->editedParam = NumParamsConst;

				const auto dragFlags = ImGuiSliderFlags_Vertical | ImGuiSliderFlags_NoInput;

				// extra spacing
				ImGui::Dummy(ImVec2());

				if (ImGui::BeginChild("Reverb", ImVec2(173, 70), ImGuiChildFlags_Border, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
					auto flags = ImGuiKnobFlags_NoInput;
					auto variant = ImGuiKnobVariant_Tick;

					ImGui::SetCursorPos(ImVec2(48.0, 16.0));
					ImGui::Text("SEND");
					ImGui::SetCursorPosX(46.0);
					ImGui::SetNextItemWidth(32.0);
					ImGui::DragInt("##send", &plugin->reverbSend, 0.1, -125, 125, plugin->reverbSend != 0 ? "%d" : "---", dragFlags);

					plugin->ImGuiDragIntPost();

					if (ImGui::IsItemHovered()) {
						float wheel = ImGui::GetIO().MouseWheel;

						if (wheel) {
							plugin->reverbSend = std::clamp(int(plugin->reverbSend + (wheel > 0 ? 1 : -1)), -125, 125);
						}
						
						static char hint[] = "Send reverb to effect track number";
						plugin->currentHint = hint;
					}

					ImGui::SetCursorPos(ImVec2(92.0, 8.0));
					ImGuiKnobs::KnobInt("LVL", &plugin->ParamValue[ReverbSendLvMult], 0, 200, 0.0f, nullptr, variant, 40.0f, flags);
					plugin->ImGuiKnobPost();
					plugin->ImGuiParam(ReverbSendLvMult, 0, 200);

				}
				ImGui::EndChild();

				ImGui::SameLine();
				if (ImGui::BeginChild("Chorus", ImVec2(173, 70), ImGuiChildFlags_Border, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
					auto flags = ImGuiKnobFlags_NoInput;
					auto variant = ImGuiKnobVariant_Tick;

					ImGui::SetCursorPos(ImVec2(48.0, 16.0));
					ImGui::Text("SEND");
					ImGui::SetCursorPosX(46.0);
					ImGui::SetNextItemWidth(32.0);
					ImGui::DragInt("##send", &plugin->chorusSend, 0.1, -125, 125, plugin->chorusSend != 0 ? "%d" : "---", dragFlags);
					
					plugin->ImGuiDragIntPost();

					if (ImGui::IsItemHovered()) {
						float wheel = ImGui::GetIO().MouseWheel;

						if (wheel) {
							plugin->chorusSend = std::clamp(int(plugin->chorusSend + (wheel > 0 ? 1 : -1)), -125, 125);
						}

						static char hint[] = "Send chorus to effect track number";
						plugin->currentHint = hint;
					}

					ImGui::SetCursorPos(ImVec2(92.0, 8.0));
					ImGuiKnobs::KnobInt("LVL", &plugin->ParamValue[ChorusSendLvMult], 0, 200, 0.0f, nullptr, variant, 40.0f, flags);
					plugin->ImGuiKnobPost();
					plugin->ImGuiParam(ChorusSendLvMult, 0, 200);
				}
				ImGui::EndChild();

				// extra spacing
				ImGui::Dummy(ImVec2());

				if (ImGui::BeginChild("Envelope2", ImVec2(173, 144), ImGuiChildFlags_Border, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
					ImGui::SetCursorPos(ImVec2(9, 8));

					
					plugin->VSliderInt("##A", ImVec2(32, 128), &plugin->ParamValue[Env2Attack], 0, 5940, 0.5, "A", ImGuiSliderFlags_None);
					plugin->ImGuiParam(Env2Attack, 0, 5940);

					ImGui::PushStyleVar(ImGuiStyleVar_ItemSpacing, ImVec2(9, 8));

					ImGui::SameLine();
					plugin->VSliderInt("##D", ImVec2(32, 128), &plugin->ParamValue[Env2Decay], 0, 5940, 0.5, "D", ImGuiSliderFlags_None);
					plugin->ImGuiParam(Env2Decay, 0, 5940);

					ImGui::SameLine();
					plugin->VSliderInt("##S", ImVec2(32, 128), &plugin->ParamValue[Env2Sustain], 0, 127, 0.5, "S", ImGuiSliderFlags_None);
					plugin->ImGuiParam(Env2Sustain, 0, 127);

					ImGui::SameLine();
					plugin->VSliderInt("##R", ImVec2(32, 128), &plugin->ParamValue[Env2Release], 0, 5940, 0.5, "R", ImGuiSliderFlags_None);
					plugin->ImGuiParam(Env2Release, 0, 5940);

					ImGui::PopStyleVar();
				}
				ImGui::EndChild();

				ImGui::SameLine();
				if (ImGui::BeginChild("RightColumn", ImVec2(0, 144))) {
					if (ImGui::BeginChild("LFO2", ImVec2(0, 70), ImGuiChildFlags_Border, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
						auto flags = ImGuiKnobFlags_NoInput;
						auto variant = ImGuiKnobVariant_Tick;

						ImGui::Dummy(ImVec2(16, 0)); ImGui::SameLine();

						ImGuiKnobs::KnobInt("DEL", &plugin->ParamValue[Lfo2Delay], 0, 5900, 0.0f, nullptr, variant, 40.0f, flags);
						plugin->ImGuiKnobPost();
						plugin->ImGuiParam(Lfo2Delay, 0, 5900);

						ImGui::SameLine();
						ImGuiKnobs::KnobInt("AMT", &plugin->ParamValue[Lfo2Amount], 0, 256, 0.0f, nullptr, variant, 40.0f, flags);
						plugin->ImGuiKnobPost();
						plugin->ImGuiParam(Lfo2Amount, 0, 256);

						ImGui::SameLine();
						ImGuiKnobs::KnobInt("SPD", &plugin->ParamValue[Lfo2Speed], 0, 127, 0.0f, nullptr, variant, 40.0f, flags);
						plugin->ImGuiKnobPost();
						plugin->ImGuiParam(Lfo2Speed, 0, 127);

					}
					ImGui::EndChild();

					if (ImGui::BeginChild("MISC", ImVec2(0, 70), ImGuiChildFlags_Border, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoScrollWithMouse)) {
						auto flags = ImGuiKnobFlags_NoInput;
						auto variant = ImGuiKnobVariant_Tick;

						ImGui::Dummy(ImVec2(64, 0)); ImGui::SameLine();

						ImGuiKnobs::KnobInt("CUT", &plugin->ParamValue[InitialFilterCutoff], 0, 127, 0.0f, nullptr, variant, 40.0f, flags);
						plugin->ImGuiKnobPost();
						plugin->ImGuiParam(InitialFilterCutoff, 0, 127);

						ImGui::SameLine();
						ImGuiKnobs::KnobInt("MOD", &plugin->ParamValue[Modulation], 0, 127, 0.0f, nullptr, variant, 40.0f, flags);
						plugin->ImGuiKnobPost();
						plugin->ImGuiParam(Modulation, 0, 127);
					}
					ImGui::EndChild();
				}
				ImGui::EndChild();

#ifdef SFLT_MIDI_In

				ImGui::SetCursorPosY(309);

				ImGui::SetNextItemWidth(32.0);

				if (ImGui::DragInt("port", &plugin->midiPort, 0.1, -1, 255, plugin->midiPort != -1 ? "%d" : "---", dragFlags)) {
					plugin->UpdatePresetIdx();
				}

				if (ImGui::IsItemHovered()) {
					static char hint[] = "MIDI in port";
					plugin->currentHint = hint;
				}

				ImGui::SetNextItemWidth(32.0);


				if (ImGui::DragInt("channel", &plugin->midiChannel, 0.1, 0, 16, plugin->midiChannel != 0 ? "%d" : "---", dragFlags)) {
					plugin->UpdatePresetIdx();
				}

				if (ImGui::IsItemHovered()) {
					static char hint[] = "MIDI channel settings";
					plugin->currentHint = hint;
				}
				
#endif
				ImGui::SetCursorPosY(309);
				ImGui::SetNextItemWidth(80.0);
				
				if (ImGui::BeginCombo("##resampling", RESAMPLE_METHODS[plugin->resampling])) {

					if (ImGui::Selectable("linear"))
						plugin->resampling = SfSample::Linear;

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Default algorithm";
						plugin->currentHint = hint;
					}

					if (ImGui::Selectable("nearest"))
						plugin->resampling = SfSample::Nearest;

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Crunchy algorithm";
						plugin->currentHint = hint;
					}

					ImGui::EndCombo();
				} else {
					if (ImGui::IsItemHovered()) {
						static char hint[] = "Resampling mode";
						plugin->currentHint = hint;
					}
				}

				ImGui::SetCursorPosY(334);

				ImGui::Checkbox("filter bypass", &plugin->overrides.filterBypass);

				if (ImGui::IsItemHovered()) {
					static char hint[] = "Disable built-in lowpass";
					plugin->currentHint = hint;
				}

				ImGui::SetCursorPosY(359);

				if (ImGui::Button("settings")) {
					plugin->uiState = SFLTPlug::Settings;
				}
				
				ImGui::SameLine();

				if (ImGui::Button("about")) {
					plugin->uiState = SFLTPlug::About;
					plugin->motdIdx = std::rand() % MOTDS.size();
				}

				ImGui::SameLine();

				ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.f, 1.f, 1.f, 0.2f));
				ImGui::SetCursorPosX(166);
				ImGui::SetCursorPosY(298);

				ImGui::Text(SFLT_ASCII);
				ImGui::PopStyleColor();
				ImGui::SameLine();


				if (plugin->editedParam != NumParamsConst) {
					std::string hint = plugin->GetParamValueString(plugin->editedParam, plugin->ParamValue[plugin->editedParam]);

					(void)hint.c_str();
					
					auto tag = plugin->HostTag;
					auto edited = plugin->editedParam;
					auto val = plugin->ParamValue[plugin->editedParam];
					
					plugin->Unlock();
					plugin->PlugHost->OnParamChanged(tag, edited, val);
					plugin->Lock();

					plugin->currentHint = hint.data();
					plugin->overrideHintUpdate = true;
					plugin->ShowHintMsg(hint.data());
				}
				
				auto drawlist = ImGui::GetForegroundDrawList();
				auto white = ImGui::ColorConvertFloat4ToU32(ImVec4(0.8, 0.8, 0.8, 1.0));

				drawlist->AddText(ImVec2(16,  73),  white, "REVERB");
				drawlist->AddText(ImVec2(197, 73),  white, "CHORUS");
				drawlist->AddText(ImVec2(16,  151), white, "ENVELOPE 2");
				drawlist->AddText(ImVec2(197, 151), white, "LFO 2");
				drawlist->AddText(ImVec2(197, 225), white, "MISC");
				drawlist->AddText(ImVec2(16,  1),   white, "PATCH");

				break;
			}



			case SFLTPlug::FileBrowser: {
				if (uiDirty)
					plugin->UpdateKbFocus();

				if (ImGui::Button("back"))
					plugin->uiState = SFLTPlug::MainMenu;

				ImGui::SameLine();
				ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
				
				if (uiDirty)
					ImGui::SetKeyboardFocusHere();
				
				if (ImGui::InputTextWithHint("##FilterSoundFonts", "Filter items", plugin->pbFilter, 64)) {
					plugin->filterDirty = true;
				}

				const auto tableFlags = ImGuiTableFlags_Sortable | ImGuiTableFlags_HighlightHoveredColumn | ImGuiTableFlags_SizingFixedFit;

				if (ImGui::BeginChild("Soundfonts", ImVec2(0, 0), ImGuiChildFlags_Border)) {
					if (ImGui::BeginTable("Soundfonts", 1, tableFlags)) {
						ImGui::TableSetupColumn(
							"Name",
							ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthStretch
						);

						ImGui::TableHeadersRow();
						ImGui::TableNextRow();

						auto sortSpecs = ImGui::TableGetSortSpecs();

						if (plugin->filterDirty) {
							plugin->filterDirty = false;
							sortSpecs->SpecsDirty = true;
						}

						if (sortSpecs->SpecsDirty) {
							plugin->browserFiles.clear();
							plugin->browserDirs.clear();

							namespace fs = std::filesystem;

							if (!fs::exists(plugin->browserDir))
								plugin->browserDir = "";

							if (plugin->browserDir == "") {
								// root, list disk drives
								DWORD drives = GetLogicalDrives();
								
								for (size_t i = 0; i < sizeof(drives) * 8; i++) {
									bool available = drives & (1 << i);

									if (!available)
										continue;

									std::string drivePath(1, 'A' + i);
									drivePath += ":";

									// check if drive is accessible
									auto drivePathChk = drivePath + "\\";
									auto driveType = GetDriveTypeA(drivePathChk.c_str());

									if (driveType < 2 || driveType == 4)
										continue;

									if (GetFileAttributesA(drivePathChk.c_str()) == INVALID_FILE_ATTRIBUTES)
										continue;

									plugin->browserDirs.push_back(drivePath);
								}

							} else {
								if (!plugin->browserDir.string().ends_with("\\"))
									plugin->browserDir = plugin->browserDir / "";

								fs::directory_iterator entries(plugin->browserDir);

								for (const auto& entry : entries) {
									auto perms = fs::status(entry).permissions();

									if ((perms & fs::perms::owner_read) == fs::perms::none)
										continue;

									auto name_wstr = entry.path().filename().wstring();
									auto name = utf8_encode(name_wstr);

									if (plugin->pbFilter[0] != 0 && !StrStrIA(name.c_str(), &plugin->pbFilter[0]))
										continue;

									if (entry.is_directory())
										plugin->browserDirs.push_back(name);
									else if (name.ends_with(".sf2") || name.ends_with(".SF2"))
										plugin->browserFiles.push_back(name);
								}
							}

							auto sortlambda = [&](const std::string& a, const std::string& b) -> bool {
								bool ascending = sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending;

								for (size_t j = 0; j < min(a.size(), b.size()); j++) {
									auto aj = std::tolower(a[j]);
									auto bj = std::tolower(b[j]);

									if (aj < bj)
										return ascending;

									if (aj > bj)
										return !ascending;
								}
								
								return a.size() < b.size() ? ascending : !ascending;
							};


							std::sort(
								plugin->browserDirs.begin(),
								plugin->browserDirs.end(),
								sortlambda
							);

							std::sort(
								plugin->browserFiles.begin(),
								plugin->browserFiles.end(),
								sortlambda
							);

							sortSpecs->SpecsDirty = false;
						}
						
						ImGui::TableSetColumnIndex(0);

						bool ascending = sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending;

						ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::ColorConvertFloat4ToU32(
							ImVec4(0.1, 0.1, 0.1, 1.0)
						));

						if (plugin->browserDir != "" && ImGui::Selectable("..")) {

							if (plugin->browserDir.string().length() <= 3) 
								plugin->browserDir = ""; // we're at root
							else 
								plugin->browserDir = plugin->browserDir.parent_path().parent_path() / "";
							
							sortSpecs->SpecsDirty = true;
						}

						ImGui::TableNextRow();

						for (int sort = 0; sort < 2; sort++) {
							if ((bool)sort == ascending) {
								// add files

								for (size_t i = 0; i < plugin->browserFiles.size(); i++) {
									const auto& file = plugin->browserFiles[i];

									ImGui::TableSetColumnIndex(0);

									if (ImGui::Selectable(file.c_str())) {
										std::filesystem::path path = plugin->browserDir;
										
										path = path / std::filesystem::u8path(file);

										plugin->LoadSoundFont(path);
										plugin->UpdateName(SFLT_RENAMESRC_SOUNDFONT);
										plugin->uiState = SFLTPlug::MainMenu;
									}

									ImGui::TableNextRow();
								}
							} else {
								// add folders

								for (size_t i = 0; i < plugin->browserDirs.size(); i++) {
									const auto& dir = plugin->browserDirs[i];

									ImGui::TableSetColumnIndex(0);

									ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::ColorConvertFloat4ToU32(
										ImVec4(0.1, 0.1, 0.1, 1.0)
									));

									if (ImGui::Selectable(dir.c_str())) {
										std::string path = plugin->browserDir.string();

										if (path != "" && !path.ends_with("\\"))
											path += "\\";
										
										path += dir + "\\";

										try {
											std::filesystem::directory_iterator entries(path);
										}
										catch (std::filesystem::filesystem_error& e) {
											// guess we can't access this dir!
											path = plugin->browserDir.string();
										}

										plugin->browserDir = path;
										sortSpecs->SpecsDirty = true;
									}

									ImGui::TableNextRow();
								}
							}
						}

						

						ImGui::EndTable();
					}
				}
				ImGui::EndChild();
				break;
			}



			case SFLTPlug::PresetBrowser: {
				if (uiDirty)
					plugin->UpdateKbFocus();

				if (ImGui::Button("back"))
					plugin->uiState = SFLTPlug::MainMenu;

				ImGui::SameLine();
				ImGui::SetNextItemWidth(ImGui::GetContentRegionAvail().x);
				

				if (uiDirty)
					ImGui::SetKeyboardFocusHere();

				if (ImGui::InputTextWithHint("##FilterPresets", "Filter presets", plugin->pbFilter, 64)) {
					plugin->filterDirty = true;
				}

				const auto tableFlags = ImGuiTableFlags_Sortable | ImGuiTableFlags_HighlightHoveredColumn | ImGuiTableFlags_SizingFixedFit;

				if (ImGui::BeginChild("Patches", ImVec2(0, 0), ImGuiChildFlags_Border)) {
					if (ImGui::BeginTable("Patches", 3, tableFlags)) {
						ImGui::TableSetupColumn(
							"Name",
							ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthStretch
						);


						ImGui::TableSetupColumn(
							"Patch",
							ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthFixed,
							48.0f
						);

						ImGui::TableSetupColumn(
							"Bank",
							ImGuiTableColumnFlags_NoResize | ImGuiTableColumnFlags_WidthFixed,
							48.0f
						);

						if (plugin->presetsListed.empty()) {
							// set default sort specs
							ImGui::TableSetColumnSortDirection(2, ImGuiSortDirection_Ascending, true);
						}

						ImGui::TableHeadersRow();
						ImGui::TableNextRow();

						auto sortSpecs = ImGui::TableGetSortSpecs();

						if (plugin->filterDirty) {
							plugin->filterDirty = false;
							sortSpecs->SpecsDirty = true;
						}

						if (sortSpecs->SpecsDirty) {
							plugin->presetsListed.clear();

							const auto& presets = plugin->soundFont->presets;

							for (size_t i = 0; i < presets.size(); i++) {
								if (plugin->pbFilter[0] != 0 && !StrStrIA(&presets[i].presetName[0], &plugin->pbFilter[0]))
									continue;

								plugin->presetsListed.push_back(i);
							}


							std::sort(
								plugin->presetsListed.begin(),
								plugin->presetsListed.end(),
								[&](size_t a, size_t b) {
									bool ascending = sortSpecs->Specs->SortDirection == ImGuiSortDirection_Ascending;

									switch (sortSpecs->Specs->ColumnIndex) {
									case 0:
										for (size_t j = 0; j < 20; j++) {
											auto aj = std::tolower(presets[a].presetName[j]);
											auto bj = std::tolower(presets[b].presetName[j]);

											if (aj < bj)
												return ascending;

											if (aj > bj)
												return !ascending;
										}

										return a < b != ascending;

									case 1:
										if (presets[a].preset == presets[b].preset) {
											return (presets[a].bank < presets[b].bank) == ascending;
										}
										else {
											return presets[a].preset < presets[b].preset == ascending;
										}

									case 2:
										if (presets[a].bank == presets[b].bank) {
											return presets[a].preset < presets[b].preset == ascending;
										}
										else {
											return presets[a].bank < presets[b].bank == ascending;
										}
									}
								}
							);


							sortSpecs->SpecsDirty = false;
						}

						for (size_t i = 0; i < plugin->presetsListed.size(); i++) {
							const auto& patch = plugin->soundFont->presets[plugin->presetsListed[i]];

							ImGui::TableSetColumnIndex(0);

							if (i % 2 == 1)
								ImGui::TableSetBgColor(ImGuiTableBgTarget_RowBg0, ImGui::ColorConvertFloat4ToU32(
									ImVec4(0.1, 0.1, 0.1, 1.0)
								));

							if (ImGui::Selectable(patch.presetName)) {
								plugin->presetBank = patch.bank;
								plugin->presetPatch = patch.preset;
								plugin->UpdatePresetIdx();
								plugin->UpdateName(SFLT_RENAMESRC_PRESET);
								plugin->uiState = SFLTPlug::MainMenu;
							}

							bool rightClickDown = ImGui::GetIO().MouseDown[1];

							static TVoiceParams PreviewParams {
								TLevelParams {
									0.0f,
									1.0f,
									6000.0f,
									1.0f,
									1.0f,
								},
								TLevelParams {
									plugin->channelPan,
									0.707f,
									0.0f,
									1.0f,
									1.0f,
								}
							};

							if (rightClickDown && ImGui::IsItemHovered()) {
								if (plugin->previewNote) {
									if (plugin->previewIdx != plugin->presetsListed[i]) {
										delete plugin->previewNote;
										plugin->previewNote = nullptr;

										plugin->previewIdx = plugin->presetsListed[i];
										
										plugin->previewNote = (Voice*)plugin->SpawnVoice(
											&PreviewParams,
											0,
											plugin->previewIdx,
											false
										);
									}
								} else {
									// No preview note yet, spawn one
									plugin->previewIdx = plugin->presetsListed[i];

									plugin->previewNote = (Voice*)plugin->SpawnVoice(
										&PreviewParams,
										0,
										plugin->previewIdx,
										false
									);
								}
							} else if (!rightClickDown) {
								if (plugin->previewNote) {
									plugin->soundFont->ReleaseVoice(*plugin->previewNote);
								}
							}

							ImGui::TableNextColumn();
							ImGui::Text("%hu", patch.preset);

							ImGui::TableNextColumn();
							ImGui::Text("%hu", patch.bank);

							ImGui::TableNextRow();
						}

						ImGui::EndTable();
					}
				}
				ImGui::EndChild();
				break;
			}


			case SFLTPlug::Settings: {
				ImGui::Text("settings");


				const size_t SYNTH_MODE_COUNT = 2;
				static std::array<const char*, SYNTH_MODE_COUNT> SYNTH_MODES = { "fruity modern", "fruity classic" };

				ImGui::Spacing();
				ImGui::Text("synth mode");
				if (ImGui::BeginCombo("##synthmode", SYNTH_MODES[plugin->synthPreset])) {
					for (size_t i = 0; i < SYNTH_MODE_COUNT; i++) {

						if (ImGui::Selectable(SYNTH_MODES[i], plugin->synthPreset == i))
							plugin->synthPreset = i;
					}

					ImGui::EndCombo();
				}

				bool configStale = false;

				ImGui::Spacing();
				ImGui::Text("default file browser path");
				{
					auto lock = CONFIG.lock_write();
					auto &path = CONFIG.get_mut().libraryPath;
					
					path.reserve(256);

					if (ImGui::InputText("##pathinput", &path)) {
						configStale = true;
						plugin->browserDir = path;
					}

					ImGui::SameLine();

					if (ImGui::Button("..")) {
						plugin->dirBrowserQueued = true;
					}

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Use native folder picker dialog";
						plugin->currentHint = hint;
					}
				}


				const size_t RENAME_MODE_COUNT = 3;
				static std::array<const char*, RENAME_MODE_COUNT> RENAME_MODES = { "none", "file", "preset" };

				ImGui::Spacing();
				ImGui::Text("rename mode");

				{
					auto lock = CONFIG.lock_write();
					auto& mode = CONFIG.get_mut().renameMode;

					if (ImGui::BeginCombo("##renamemode", RENAME_MODES[mode])) {
						for (size_t i = 0; i < RENAME_MODE_COUNT; i++) {

							if (ImGui::Selectable(RENAME_MODES[i], mode == i)) {
								configStale = true;
								mode = i;
							}
						}

						ImGui::EndCombo();
					}

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Automatically rename plugin channel to match file/preset";
						plugin->currentHint = hint;
					}
				}
				
				{
					auto lock = CONFIG.lock_write();
					auto& threaded = CONFIG.get_mut().threadedLoadingEnabled;

					ImGui::Spacing();
					if (ImGui::Checkbox("threaded loading", &threaded))
						configStale = true;

					if (ImGui::IsItemHovered()) {
						static char hint[] = "Load SoundFonts without blocking main thread (experimental)";
						plugin->currentHint = hint;
					}

				}

				if (configStale)
					SaveConfig();
				

				ImGui::SetCursorPosY(359);

				if (ImGui::Button("back"))
					plugin->uiState = SFLTPlug::MainMenu;

				break;
			}


			case SFLTPlug::About: {
				if (ImGui::Button("back"))
					plugin->uiState = SFLTPlug::MainMenu;

				ImGui::Text(SFLT_ASCII);
				ImGui::Text(VERSION_STRING);

				ImGui::TextWrapped(
					"by ash taylor\n"
					"\n"
					"\n"
					"libraries used (licenses below):\n"
					"  Dear ImGUI - Copyright (c) 2014-2024 Omar Cornut\n"
					"  ImGui Knobs - Copyright (c) 2022 Simon Altschuler\n"
					"  tinyfiledialogs - Copyright (C) 2014-2024 Guillaume Vareille\n"
					"\n"
					"these libraries are licensed under MIT -- license text below\n"
					"\n"
					"-----------------------\n"
					"\n"
					"The MIT License (MIT)\n"
					"\n"
					"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:\n\n"

					"The above copyright notice and this permission notice shall be included in all "
					"copies or substantial portions of the Software.\n\n"

					"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.\n"
					"\n"
					"-----------------------\n"
					"\n"
				);


				auto windowWidth = ImGui::GetWindowSize().x;
				auto textWidth = ImGui::CalcTextSize(MOTDS[plugin->motdIdx]).x;

				ImGui::PushStyleColor(ImGuiCol_Text, ImVec4(1.0, 1.0, 1.0, 0.5));
				ImGui::SetCursorPosX((windowWidth - textWidth) * 0.5f);

				ImGui::Text(MOTDS[plugin->motdIdx]);

				ImGui::PopStyleColor();


				break;
			}

			case SFLTPlug::Debug:
				if (ImGui::Button("Back"))
					plugin->uiState = SFLTPlug::MainMenu;

				ImGui::Checkbox("Output Envelope", &plugin->dbgOutputEnv);

				for (const auto& v: plugin->VoiceList) {
					
					ImGui::Text("voice");
					ImGui::Text("  released: %s", v->Released ? "true" : "false");
					ImGui::Text("  instVoices:");
					
					for (const auto& iv: v->instVoices) {
						ImGui::Text("    iv");
						ImGui::Text("      iZone: %p", iv.iZone);
						ImGui::Text("      pZone: %p", iv.pZone);
						ImGui::Text("      iGlobalZone: %p", iv.iGlobalZone);
						ImGui::Text("      pGlobalZone: %p", iv.pGlobalZone);
						ImGui::Text("      filter cutoff: %f", iv.filter.GetResonantFreq());
					}
				}
				
				break;

			}

			if (!plugin->overrideHintUpdate && lastHint != plugin->currentHint) {
				// update hint
				plugin->ShowHintMsg(plugin->currentHint);
			}
		}
		ImGui::End();
		plugin->Unlock();

		ImGui::Render();
		glViewport(0, 0, PLUGIN_WIDTH, PLUGIN_HEIGHT);
		glClearColor(0.0, 0.0, 0.0, 1.0);
		glClear(GL_COLOR_BUFFER_BIT);
		
		ImGui_ImplOpenGL3_RenderDrawData(ImGui::GetDrawData());
		::SwapBuffers(hdc);

		EndPaint(hwnd, &ps);

		plugin->Lock();
		plugin->imFrameActive = false;
		plugin->Unlock();

		return 0;
	}

	// default
	return DefWindowProc(hwnd, message, wParam, lParam);
}

void SFLTPlug::UnloadSoundFont() {
	if (!soundFont) {
		return;
	}
	
	ClearVoices();

	if (soundFont.use_count() == 2) {
		auto guard = SOUNDFONTS.lock_write();
		auto& sfmem = SOUNDFONTS.get_mut();
		sfmem.erase(currentFile);
	}
	
	soundFont = nullptr;
	presetsListed.clear();
	presetScrollList.clear();
}

void SFLTPlug::UpdateName(int source) {
	// update naming depending on rename mode
	// this should only be called from the GUI thread, as it interacts with the mutex state (and expects it to be locked)

	int renameMode = 0;
	{
		auto lock = CONFIG.lock_read();
		const auto& config = CONFIG.get();

		renameMode = config.renameMode;
	}

	if (!soundFont)
		return;
	
	if (renameMode == SFLTSharedConfig::Preset) {
		if (!presetExists)
			return;

		currentPlugName = (const char8_t*)soundFont->presets[presetIdx].presetName;

		Unlock();
		PlugHost->Dispatcher(HostTag, FHD_SetNewName, 0, (intptr_t)currentPlugName.c_str());
		Lock();
	} 
	else if (source == 1 && renameMode == SFLTSharedConfig::SoundFont) {
		auto slash = currentFile_u8.rfind('\\');

		if (slash == std::string::npos)
			slash = currentFile_u8.rfind('/');

		currentPlugName = currentFile_u8.substr(slash + 1, currentFile_u8.size() - slash - 5);
		
		Unlock();
		PlugHost->Dispatcher(HostTag, FHD_SetNewName, 0, (intptr_t)currentPlugName.c_str());
		Lock();
	}
}

void SFLTPlug::LoadSoundFont(const std::filesystem::path& path, bool forceSync) {
	if (loadingThreaded.load())
		return;

	if (soundFont) {
		UnloadSoundFont();
	} else {
		ClearVoices();
	}

	currentFileExists = false;
	currentFile = path;
	currentFile_u8 = path.u8string();


	// check if file already in memory
	// 
	// maybe a little overzealous with the write lock,
	// but there's a lot of potential for race conditions
	// when loading a project and many SFLT instances try
	// to fetch the same SoundFonts all at once

	auto guard = SOUNDFONTS.lock_write();
	auto& sfmem = SOUNDFONTS.get_mut();

	if (sfmem.contains(currentFile)) {
		soundFont = sfmem.at(currentFile);
		currentFileExists = true;
		UpdatePresetIdx();
			
		return;
	}
	
	// file not in memory, load & store it
	{
		bool threaded = false;

		if (!forceSync) {
			auto lock = CONFIG.lock_read();
			const auto& config = CONFIG.get();

			threaded = config.threadedLoadingEnabled;
		}

		if (threaded) {
			loadingThreaded.store(true);

			try {
				threadFileSize = std::filesystem::file_size(currentFile);
			}
			catch (std::exception& e) {
				threadFileSize = -1;
			}
			
			std::thread loadthread([&, path]() {
				// separate write lock, will only unblock after LoadSoundFont() returns
				auto guard = SOUNDFONTS.lock_write();
				auto& sfmem = SOUNDFONTS.get_mut();

				try {
					sfmem[path] = std::make_shared<sfhi::SoundFontSynth>(sfhi::SoundFontSynth::LoadFromFile(path, &threadProgress));
					loadingThreaded.store(false);
					loadingFinished.store(true);
				}
				catch (std::runtime_error& e) {
					// failed to load, just return. currentFileExists indicates failure state
					loadingThreaded.store(false);
					loadingFinished.store(true);
					return;
				}}
			);

			loadthread.detach();
		}
		else {
			// synchronous loading
			try {
				sfmem[currentFile] = std::make_shared<sfhi::SoundFontSynth>(sfhi::SoundFontSynth::LoadFromFile(path));
				soundFont = sfmem.at(currentFile);
				currentFileExists = true;
			}
			catch (std::runtime_error& e) {
				// failed to load, just return. currentFileExists indicates failure state
				return;
			}
		}
	}
	
	UpdatePresetIdx();
}


void SFLTPlug::UpdatePresetIdx() {
	presetExists = false;
	presetIdx = 0;
	presetScrollIdx = 0;

	if (soundFont && presetScrollList.empty()) {
		presetScrollList.reserve(soundFont->presets.size());
		
		for (size_t i = 0; i < soundFont->presets.size(); i++)
			presetScrollList.push_back(i);

		std::sort(presetScrollList.begin(), presetScrollList.end(), [&](size_t a, size_t b) {
			if (soundFont->presets[a].bank == soundFont->presets[b].bank) {
				return soundFont->presets[a].preset < soundFont->presets[b].preset;
			}
			else {
				return soundFont->presets[a].bank < soundFont->presets[b].bank;
			}
		});
	}

	if (soundFont && soundFont->presetMap.contains(presetBank)) {
		if (soundFont->presetMap[presetBank].contains(presetPatch)) {
			presetIdx = soundFont->presetMap[presetBank][presetPatch];
			presetScrollIdx = std::find(presetScrollList.begin(), presetScrollList.end(), presetIdx) - presetScrollList.begin();

			if (presetIdx < soundFont->presets.size())
				presetExists = true;
		}
	}
}

SFLTPlug::SFLTPlug(int SetHostTag, TFruityPlugHost* SetPlugHost, HINSTANCE SetInstance) : TCPPFruityPlug(SetHostTag, SetPlugHost, SetInstance) {
	Info = &PlugInfo;

	WNDCLASS windowClass{};
	windowClass.style = CS_DBLCLKS;
	windowClass.lpfnWndProc = PlgWndProc;
	windowClass.cbClsExtra = 0;
	windowClass.cbWndExtra = 0;
	windowClass.hInstance = HInstance;
	windowClass.hIcon = 0;
	windowClass.hCursor = 0;
	windowClass.hbrBackground = 0;
	windowClass.lpszMenuName = 0;
	windowClass.lpszClassName = L"SFLTWindow";
	RegisterClass(&windowClass);

	UpdateSkin();
	{
		auto lock = CONFIG.lock_read();
		const auto& config = CONFIG.get();

		browserDir = config.libraryPath; 
		auto browserDirStr = browserDir.string();

		if (!browserDirStr.ends_with("\\") && !browserDirStr.ends_with("/"))
			browserDir = browserDir / "";

	}

	//PlugHost->Dispatcher(HostTag, FHD_WantMIDIInput, 0, 1);
}

SFLTPlug::~SFLTPlug()
{
	UnloadSoundFont();

	if (ctx) {
		ImGui::SetCurrentContext(ctx);

		ImGui_ImplOpenGL3_Shutdown();
		ImGui_ImplWin32_Shutdown();

		ImGui::DestroyContext(ctx);
	}
	
	if (EditorHandle) {
		auto hdc = ::GetDC(EditorHandle);
		CleanupDeviceWGL(EditorHandle, hdc);
		DestroyWindow(EditorHandle);
		EditorHandle = 0;
	}

	if (g_hRC) {
		wglDeleteContext(g_hRC);
	}
}

intptr_t _stdcall SFLTPlug::Dispatcher(intptr_t ID, intptr_t Index, intptr_t Value)
{
	intptr_t r = TCPPFruityPlug::Dispatcher(ID, Index, Value);

	if (r != 0)
		return r;

	switch (ID)
	{
	case FPD_ShowEditor: {
		// show or hide the plugin editor
		Lock();

		if (Value == 0) {
			// hide (no parent window)
			auto hdc = ::GetDC(EditorHandle);
			
			CleanupDeviceWGL(EditorHandle, hdc);
			DestroyWindow(EditorHandle);
			EditorHandle = 0;
			
			Unlock();
		}
		else {
			// show

			EditorHandle = CreateWindowEx(
				0,
				L"SFLTWindow",
				L"SFLTWindow",
				WS_CHILD | WS_VISIBLE,
				0,
				0,
				PLUGIN_WIDTH,
				PLUGIN_HEIGHT,
				(HWND)Value,
				NULL,
				HInstance,
				NULL
			);

			SetWindowLongPtr(EditorHandle, GWLP_USERDATA, (LONG_PTR)this);

			RECT rect;
			GetWindowRect((HWND)Value, &rect);

			auto hdc = ::GetDC(EditorHandle);

			if (!CreateDeviceWGL(EditorHandle, hdc, g_hRC)) {
				CleanupDeviceWGL(EditorHandle, hdc);
				::DestroyWindow(EditorHandle);
				Unlock();
				return 1;
			}

			wglMakeCurrent(hdc, g_hRC);

			IMGUI_CHECKVERSION();

			if (!ctx) {
				ctx = ImGui::CreateContext();
			}
			ImGui::SetCurrentContext(ctx);
			UpdateSkin();

			if (ImInit) {
				ImGui_ImplOpenGL3_Shutdown();
				ImGui_ImplWin32_Shutdown();
			}

			ImGui_ImplWin32_InitForOpenGL(EditorHandle);
			ImGui_ImplOpenGL3_Init();
			ImInit = true;
			
			Unlock();
		}

		break;
	}

	case FPD_GetParamType:
		r = PT_Value;
		break;

	case FPD_Flush:
		Lock();
		ClearVoices();
		Unlock();
		break;
		
	case FPD_SetSampleRate: {
		Lock();
		AudioRenderer.setSmpRate(Value);
		PitchMul = MiddleCMul / AudioRenderer.getSmpRate();
		Unlock();
		break;
	}
	
	case FPD_SetFocus:
		focused = (bool)Value;
		UpdateKbFocus();
		break;

	case FPD_StealKBFocus:
		kbFocusAllowed = (bool)Value;
		UpdateKbFocus();
		break;
		
	case FPD_LoadFile:
		// doesn't work lol. fl forces the default sf player
		try {
			LoadSoundFont((const char*)Value);
			return 1;
		}
		catch (std::runtime_error e) {
			return 2;
		}
	}

	return r;
}


void SFLTPlug::UpdateKbFocus() {
	HWND parent = (HWND)PlugHost->AppHandle;

	bool prevWantKbFocus = wantKbFocus;

	if (!EditorHandle || !focused || !kbFocusAllowed) {
		wantKbFocus = false;
	}
	else {
		switch (uiState) {

		case MainMenu:
		case About:
			wantKbFocus = false;
			break;

		default:
			wantKbFocus = true;
			break;

		}
	}

	if (wantKbFocus != prevWantKbFocus) {
		if (wantKbFocus) {
			SetFocus(EditorHandle);
		} else {
			SetFocus(parent);
		}
	}
}


void _stdcall SFLTPlug::SaveRestoreState(IStream* Stream, BOOL Save)
{
	if (Save)
	{
		// first write a version number, so we can change the format later on if we want to
		long version = PlugVersion;
		Stream->Write(&version, 4, NULL);

		// save your settings to Stream
		Stream->Write(&ParamValue, sizeof(ParamValue), NULL);

		size_t filenameSize = currentFile_u8.size();

		Stream->Write(&filenameSize, sizeof(size_t), NULL);
		Stream->Write(currentFile_u8.c_str(), filenameSize, NULL);

		Stream->Write(&presetIdx, sizeof(presetIdx), NULL);

		Stream->Write(&reverbSend, sizeof(reverbSend), NULL);
		Stream->Write(&chorusSend, sizeof(chorusSend), NULL);
		Stream->Write(&midiPort, sizeof(midiPort), NULL);
		Stream->Write(&midiChannel, sizeof(midiChannel), NULL);
		Stream->Write(&resampling, sizeof(resampling), NULL);

		Stream->Write(&presetExists, sizeof(presetExists), NULL);
		Stream->Write(&overrides.filterBypass, sizeof(overrides.filterBypass), NULL);
		
		int dummy = 0;

		Stream->Write(&dummy, sizeof(dummy), NULL);
		Stream->Write(&dummy, sizeof(dummy), NULL);
	}
	else
	{
		// read the saved version number
		long version = 0xFFFFFFFF;

		Stream->Read(&version, 4, NULL);

		if (version <= PlugVersion)	// we know what to do if the version is older than our own
		{
			// load previously saved settings
			Stream->Read(&ParamValue, sizeof(ParamValue), NULL);

			if (version >= 3) {
				size_t filenameSize = 0;

				Stream->Read(&filenameSize, sizeof(size_t), NULL);

				if (filenameSize != 0) {
					std::u8string path;

					path.resize(filenameSize);
					Stream->Read(path.data(), filenameSize, NULL);

					LoadSoundFont(path, true);
				}

				Stream->Read(&presetIdx, sizeof(presetIdx), NULL);

				Stream->Read(&reverbSend, sizeof(reverbSend), NULL);
				Stream->Read(&chorusSend, sizeof(chorusSend), NULL);
				Stream->Read(&midiPort, sizeof(midiPort), NULL);

				Stream->Read(&midiChannel, sizeof(midiChannel), NULL);
			}
			
			if (version >= 4) {
				Stream->Read(&resampling, sizeof(resampling), NULL);
			}

			if (version >= 5) {
				Stream->Read(&presetExists, sizeof(presetExists), NULL);
				Stream->Read(&overrides.filterBypass, sizeof(overrides.filterBypass), NULL);
			}
			
			if (version >= 6) {
				int throwaway;
				Stream->Read(&throwaway, sizeof(throwaway), NULL);
				Stream->Read(&throwaway, sizeof(throwaway), NULL);
			}

			if (soundFont) {
				presetBank = soundFont->presets[presetIdx].bank;
				presetPatch = soundFont->presets[presetIdx].preset;
				UpdatePresetIdx();
			}
		}
	}
}


void _stdcall SFLTPlug::GetName(int Section, int Index, int Value, char* Name)
{
	if (Section == FPN_Param) {
		switch (Index) {
		case ReverbSendLvMult:		strcpy_s(Name, 256, "Reverb send level (multiplier)"); break;
		case ChorusSendLvMult:		strcpy_s(Name, 256, "Chorus send level (multiplier)"); break;
		case Modulation:			strcpy_s(Name, 256, "Modulation"); break;
		case Env2Attack:			strcpy_s(Name, 256, "Env 2 attack time"); break;
		case Env2Decay:				strcpy_s(Name, 256, "Env 2 decay time"); break;
		case Env2Sustain:			strcpy_s(Name, 256, "Env 2 sustain level"); break;
		case Env2Release:			strcpy_s(Name, 256, "Env 2 release time"); break;
		case Lfo2Delay:				strcpy_s(Name, 256, "LFO 2 predelay"); break;
		case Lfo2Amount:			strcpy_s(Name, 256, "LFO 2 amount"); break;
		case Lfo2Speed:				strcpy_s(Name, 256, "LFO 2 speed"); break;
		case InitialFilterCutoff:	strcpy_s(Name, 256, "Initial filter cutoff"); break;
		}
	}
	else if (Section == FPN_ParamValue) {
		auto text = GetParamValueString(Index, Value);

		strcpy_s(Name, 256, text.c_str());
	}
}

std::string SFLTPlug::GetParamValueString(int param, int value) {
	if (value == 0) {
		return "Disabled";
	}
	else {
		switch (param) {

		case Lfo2Amount:
			return std::to_string(value - 129);
			break;

		default:
			return std::to_string(value);

		}
	}
}

int _stdcall SFLTPlug::ProcessParam(int ThisIndex, int ThisValue, int RECFlags)
{
	Lock();

	if ((RECFlags & REC_FromMIDI) == REC_FromMIDI)
		ThisValue = TranslateMidi(ThisValue, 0, GetParamMaxValue(ThisIndex));	// REC_FromMIDI means the value is between 0 and 65536. Here we convert it to our own range (volume parameter will be between 0 and 100)

	if ((RECFlags & REC_GetValue) == REC_GetValue)
		ThisValue = ParamValue[ThisIndex];

	if ((RECFlags & REC_UpdateValue) == REC_UpdateValue)
		ParamValue[ThisIndex] = ThisValue;

	if ((RECFlags & REC_UpdateControl) == REC_UpdateControl)
	{
		// update the parameter's control on the GUI now
		if (EditorHandle)
			RedrawWindow(EditorHandle, NULL, NULL, RDW_INTERNALPAINT);
	}
	
	Unlock();

	return ThisValue;	// return the value (in case of REC_FromMIDI or REC_GetValue)
}




void _stdcall SFLTPlug::Gen_Render(PWAV32FS DestBuffer, int& Length)
{
	Lock();

	if (!soundFont) {
		Unlock();
		return;
	}

	soundFont->sampleRate = AudioRenderer.getSmpRate();

	overrides.attack = ParamValue[Env2Attack];
	overrides.decay = ParamValue[Env2Decay];
	overrides.sustain = ParamValue[Env2Sustain];
	overrides.release = ParamValue[Env2Release];

	overrides.lfo2Del = ParamValue[Lfo2Delay];
	overrides.lfo2Amt = ParamValue[Lfo2Amount];
	overrides.lfo2Spd = ParamValue[Lfo2Speed];
	
	overrides.filterFc = ParamValue[InitialFilterCutoff];
	overrides.modulation = ParamValue[Modulation];

	for (auto v: VoiceList) {
		RenderVoice(v, DestBuffer, Length);
	}

	if (previewNote) {
		RenderVoice(previewNote, DestBuffer, Length);
	}

	for (auto v : VoiceList) {
		if (!v->HasActiveVoices) {
			PlugHost->Voice_Kill(v->HostTag, TRUE);
		}
	}

	if (previewNote && !previewNote->HasActiveVoices) {
		previewNote->Dummy = true;
	}

	Unlock();
}

void _stdcall SFLTPlug::RenderVoice(Voice* v, PWAV32FS DestBuffer, int Length) {
	float LVol, RVol;

	PWAV32FM VBuffer = (PWAV32FM)PlugHost->TempBuffers[0];
	PWAV32FM IVBuffer = (PWAV32FM)PlugHost->TempBuffers[1];
	PWAV32FM EnvBuffer = (PWAV32FM)PlugHost->TempBuffers[2];
	PWAV32FM TmpIVBuffer = (PWAV32FM)PlugHost->TempBuffers[3];

	v->PitchOffset = (v->Params->FinalLevels.Pitch / 100.0) + (60.0 - v->InitPitch);

	memset(EnvBuffer, 0, Length * sizeof(float));
	memset(VBuffer, 0, Length * sizeof(float) * 2);

	if (v->Dummy)
		return;

	// Process Generators & Modulators
	soundFont->UpdateVoice(*v, Length);

	// calculate channel velocity because the FL SDK sucks
	float initLinear = VolumeToVelocity(v->Params->InitLevels.Vol);
	float finalLinear = VolumeToVelocity(v->Params->FinalLevels.Vol);
	float channelVol = 0.0f;

	if (initLinear != 0.0f)
		channelVol = finalLinear / initLinear;

	float channelVolFL = VelocityToFLVolume(channelVol);

	PlugHost->ComputeLRVol(LVol, RVol, v->Params->FinalLevels.Pan, channelVolFL);

	if (v->FirstRendering) {
		v->LastLVol = LVol;
		v->LastRVol = RVol;
	}

	v->HasActiveVoices = false;

	for (auto& iv : v->instVoices) {
		float Pan = (float)iv.GenValues[SfGen::Pan].shAmount / 500.0;
		float LVolIv, RVolIv;

		memset(IVBuffer, 0, Length * sizeof(float));

		PlugHost->ComputeLRVol(LVolIv, RVolIv, Pan, 1.0f);

		if (v->FirstRendering) {
			iv.LastLVol = LVolIv;
			iv.LastRVol = RVolIv;
		}

		if (iv.volEnv.state != sfhi::EnvState::Stop)
			v->HasActiveVoices = true;

		if (dbgOutputEnv) {
			// debug env output
			soundFont->RenderVolEnvelope(iv, IVBuffer, Length, v->overrides);
			PlugHost->AddWave_32FM_32FS_Ramp(IVBuffer, VBuffer, Length, LVolIv, RVolIv, iv.LastLVol, iv.LastRVol);
		}
		else {
			// real output
			soundFont->RenderVolEnvelope(iv, EnvBuffer, Length, v->overrides);

			if (soundFont->RenderInstVoice(v, &iv, IVBuffer, Length, EnvBuffer, resampling)) {
				memset(TmpIVBuffer, 0, Length * sizeof(float) * 2);

				PlugHost->AddWave_32FM_32FS_Ramp(IVBuffer, TmpIVBuffer, Length, LVolIv, RVolIv, iv.LastLVol, iv.LastRVol);

				auto mainAmp = 1.0f;

				// reverb & chorus send
				if (reverbSend != 0 || chorusSend != 0) {
					void* ReverbBuf = reverbSend != 0 ? PlugHost->GetInsBuffer(HostTag, reverbSend) : nullptr;
					void* ChorusBuf = chorusSend != 0 ? PlugHost->GetInsBuffer(HostTag, chorusSend) : nullptr;

					if (ParamValue[ReverbSendLvMult] > 0)
						iv.GenValues[SfGen::ReverbEffectsSend].shAmount = ParamValue[ReverbSendLvMult];

					if (ParamValue[ChorusSendLvMult] > 0)
						iv.GenValues[SfGen::ChorusEffectsSend].shAmount = ParamValue[ChorusSendLvMult];

					if (ChorusBuf) {
						auto chorusAmpL = iv.GenValues[SfGen::ChorusEffectsSend].shAmount / 1000.0f * LVol;
						auto chorusAmpR = iv.GenValues[SfGen::ChorusEffectsSend].shAmount / 1000.0f * RVol;

						PlugHost->AddWave_32FS_32FS_Ramp(TmpIVBuffer, ChorusBuf, Length, chorusAmpL, chorusAmpR, chorusAmpL, chorusAmpR);
					}

					if (ReverbBuf) {
						auto reverbAmpL = iv.GenValues[SfGen::ReverbEffectsSend].shAmount / 1000.0f * LVol;
						auto reverbAmpR = iv.GenValues[SfGen::ReverbEffectsSend].shAmount / 1000.0f * RVol;

						PlugHost->AddWave_32FS_32FS_Ramp(TmpIVBuffer, ReverbBuf, Length, reverbAmpL, reverbAmpR, reverbAmpL, reverbAmpR);
					}
				}

				// main write to voice buffer
				PlugHost->AddWave_32FS_32FS_Ramp(TmpIVBuffer, VBuffer, Length, 1.0f, 1.0f, mainAmp, mainAmp);
			}

			// mod envelope is currently not rendered at full res, just update it once
			soundFont->RenderModEnvelope(iv, nullptr, Length);
		}
	}

	v->FirstRendering = false;

	PlugHost->AddWave_32FS_32FS_Ramp(VBuffer, DestBuffer, Length, LVol, RVol, v->LastLVol, v->LastRVol);
}

TVoiceHandle _stdcall SFLTPlug::TriggerVoice(PVoiceParams VoiceParams, intptr_t SetTag)
{
	Lock();

	auto result = SpawnVoice(VoiceParams, SetTag, presetIdx, !presetExists);

	VoiceList.push_back(result);

	if (polyphony != 0 && VoiceList.size() > polyphony) {
		auto lastV = VoiceList.front();
		VoiceList.pop_front();

		PlugHost->Voice_Kill(lastV->HostTag, false);
		delete lastV;
	}

	Unlock();

	return (TVoiceHandle)result;
}

Voice* _stdcall SFLTPlug::SpawnVoice(PVoiceParams VoiceParams, intptr_t SetTag, size_t PresetIdx, bool Dummy)
{
	if (!soundFont) {
		// no soundfont, create dummy voice
		auto v = new Voice;

		v->HostTag = SetTag;
		v->Dummy = true;

		return v;
	}

	// create our new voice and set its parameters

	auto v = soundFont->SpawnVoice(VoiceParams, PresetIdx, &overrides);

	v->HostTag = SetTag;
	v->Dummy = Dummy;

	// kill other instvoices with the same exclusive class

	for (const auto& iv : v->instVoices) {
		if (iv.GenValues[SfGen::ExclusiveClass].wAmount == 0)
			continue;

		for (auto& otherV : VoiceList) {
			for (auto& otherIv : otherV->instVoices) {
				if (iv.GenValues[SfGen::ExclusiveClass].wAmount == otherIv.GenValues[SfGen::ExclusiveClass].wAmount) {
					otherIv.volEnv.state = sfhi::EnvState::Stop;
				}
			}
		}
	}

	// return a handle so the host can tell us when something happens to it
	// we use the voice class' pointer for this, since it's supposed to be unique within the process
	return v;
}

void _stdcall SFLTPlug::Voice_Release(TVoiceHandle Handle)
{
	Lock();

	Voice* v = (Voice*)Handle;
	
	if (soundFont) {
		soundFont->ReleaseVoice(*v);
		Unlock();
	}
	else {
		Unlock();
		PlugHost->Voice_Kill(v->HostTag, true);
	}
}

void _stdcall SFLTPlug::Voice_Kill(TVoiceHandle Handle)
{
	Lock();

	// handle is the value we returned in TriggerVoice, so it's really a pointer to a TVoice object
	Voice* v = (Voice*)Handle;

	// remove it from the list
	VoiceList.remove(v);
	delete v;
	Unlock();
}

void SFLTPlug::ClearVoices()
{
	for (auto v : VoiceList) {
		PlugHost->Voice_Kill(v->HostTag, false);
		delete v;
	}
	VoiceList.clear();
}

int _stdcall SFLTPlug::ProcessEvent(int EventID, int EventValue, int Flags) {
	Lock();

	switch (EventID) {

	case FPE_MaxPoly:
		polyphony = EventValue;
		break;

	case FPE_MIDI_Vol:
		channelVol = float(EventValue) / 127.0f;
		break;

	case FPE_MIDI_Pan:
		channelPan = float(Flags) / 64.0f;
		break;
	}
	
	Unlock();

	return 0;
}

int _stdcall SFLTPlug::Voice_ProcessEvent(TVoiceHandle Handle, int EventID, int EventValue, int Flags)
{
	return 0;
}

void _stdcall SFLTPlug::MIDIIn(int& Msg) {
	Lock();

	auto msg = (TMIDIOutMsg)Msg;

	if (msg.Port == midiPort) {
		lastMidiMsg = Msg;
	}
	
	Unlock();
}

// Helper functions
bool CreateDeviceWGL(HWND hWnd, HDC& data, HGLRC& g_hRC)
{
	HDC hDc = ::GetDC(hWnd);
	PIXELFORMATDESCRIPTOR pfd = { 0 };
	pfd.nSize = sizeof(pfd);
	pfd.nVersion = 1;
	pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
	pfd.iPixelType = PFD_TYPE_RGBA;
	pfd.cColorBits = 32;

	const int pf = ::ChoosePixelFormat(hDc, &pfd);

	if (pf == 0)
		return false;

	if (::SetPixelFormat(hDc, pf, &pfd) == FALSE)
		return false;

	::ReleaseDC(hWnd, hDc);

	data = ::GetDC(hWnd);
	
	if (g_hRC)
		wglDeleteContext(g_hRC);
	
	g_hRC = wglCreateContext(data);
	return true;
}

void CleanupDeviceWGL(HWND hWnd, HDC data)
{
	wglMakeCurrent(nullptr, nullptr);
	::ReleaseDC(hWnd, data);
}