DISTRHO
/
Cardinal
mirror of https://github.com/DISTRHO/Cardinal.git
1
0
Fork 0
Code Issues 0 Releases 18 Wiki Activity
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1719 Commits
7 Branches
146MB
Tree: 1895052e17
Branches Tags
${ item.name }
Create branch ${ searchTerm }
from '1895052e17'
${ noResults }
Cardinal/src/override/diffs/Window.cpp.diff

1455 lines
46KB
Raw Blame History 

  1. --- ../Rack/src/window/Window.cpp	2023-12-17 12:57:01.139429461 +0100

  2. +++ Window.cpp	2023-10-22 13:33:43.777041594 +0200

  3. @@ -1,33 +1,94 @@

  4. +/*

  5. + * DISTRHO Cardinal Plugin

  6. + * Copyright (C) 2021-2023 Filipe Coelho <falktx@falktx.com>

  7. + *

  8. + * This program is free software; you can redistribute it and/or

  9. + * modify it under the terms of the GNU General Public License as

  10. + * published by the Free Software Foundation; either version 3 of

  11. + * the License, or any later version.

  12. + *

  13. + * This program is distributed in the hope that it will be useful,

  14. + * but WITHOUT ANY WARRANTY; without even the implied warranty of

  15. + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

  16. + * GNU General Public License for more details.

  17. + *

  18. + * For a full copy of the GNU General Public License see the LICENSE file.

  19. + */

  20. +

  21. +/**

  22. + * This file is an edited version of VCVRack's window/Window.cpp

  23. + * Copyright (C) 2016-2023 VCV.

  24. + *

  25. + * This program is free software: you can redistribute it and/or

  26. + * modify it under the terms of the GNU General Public License as

  27. + * published by the Free Software Foundation; either version 3 of

  28. + * the License, or (at your option) any later version.

  29. + */

  30. +

  31.  #include <map>

  32.  #include <queue>

  33.  #include <thread>

  34.  

  35. -#if defined ARCH_MAC

  36. -	// For CGAssociateMouseAndMouseCursorPosition

  37. -	#include <ApplicationServices/ApplicationServices.h>

  38. -#endif

  39. -

  40. -#include <stb_image_write.h>

  41. -#include <osdialog.h>

  42. -

  43.  #include <window/Window.hpp>

  44.  #include <asset.hpp>

  45.  #include <widget/Widget.hpp>

  46.  #include <app/Scene.hpp>

  47. -#include <keyboard.hpp>

  48. -#include <gamepad.hpp>

  49.  #include <context.hpp>

  50.  #include <patch.hpp>

  51.  #include <settings.hpp>

  52. -#include <plugin.hpp> // used in Window::screenshot

  53. -#include <system.hpp> // used in Window::screenshot

  54. +#include <system.hpp>

  55. +

  56. +#ifdef NDEBUG

  57. +# undef DEBUG

  58. +#endif

  59. +

  60. +#include "DistrhoUI.hpp"

  61. +#include "Application.hpp"

  62. +#include "extra/String.hpp"

  63. +#include "../CardinalCommon.hpp"

  64. +#include "../PluginContext.hpp"

  65. +#include "../WindowParameters.hpp"

  66. +

  67. +#ifndef DGL_NO_SHARED_RESOURCES

  68. +# include "src/Resources.hpp"

  69. +#endif

  70.  

  71. +#if !(defined(DGL_USE_GLES) || CARDINAL_VARIANT_MINI)

  72. +

  73. +#define CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  74. +

  75. +// comment out if wanting to generate a local screenshot.png

  76. +#define STBI_WRITE_NO_STDIO

  77. +

  78. +// uncomment to generate screenshots without the rack rail background (ie, transparent)

  79. +// #define CARDINAL_TRANSPARENT_SCREENSHOTS

  80. +

  81. +// used in Window::screenshot

  82. +#define STB_IMAGE_WRITE_IMPLEMENTATION

  83. +#include "stb_image_write.h"

  84. +

  85. +#endif

  86. +

  87. +#ifdef DISTRHO_OS_WASM

  88. +# include <emscripten/html5.h>

  89. +#endif

  90.  

  91.  namespace rack {

  92.  namespace window {

  93.  

  94.  

  95. -static const math::Vec WINDOW_SIZE_MIN = math::Vec(640, 480);

  96. +static const math::Vec WINDOW_SIZE_MIN = math::Vec(648, 538);

  97. +

  98. +

  99. +struct FontWithOriginalContext : Font {

  100. +	int ohandle = -1;

  101. +	std::string ofilename;

  102. +};

  103. +

  104. +struct ImageWithOriginalContext : Image {

  105. +	int ohandle = -1;

  106. +	std::string ofilename;

  107. +};

  108.  

  109.  

  110.  Font::~Font() {

  111. @@ -42,9 +103,8 @@

  112.  	// Transfer ownership of font data to font object

  113.  	uint8_t* data = system::readFile(filename, &size);

  114.  	// Don't use nvgCreateFont because it doesn't properly handle UTF-8 filenames on Windows.

  115. -	handle = nvgCreateFontMem(vg, name.c_str(), data, size, 0);

  116. +	handle = nvgCreateFontMem(vg, name.c_str(), data, size, 1);

  117.  	if (handle < 0) {

  118. -		std::free(data);

  119.  		throw Exception("Failed to load font %s", filename.c_str());

  120.  	}

  121.  	INFO("Loaded font %s", filename.c_str());

  122. @@ -79,340 +139,478 @@

  123.  }

  124.  

  125.  

  126. +#ifdef CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  127. +enum ScreenshotStep {

  128. +	kScreenshotStepNone,

  129. +	kScreenshotStepStarted,

  130. +	kScreenshotStepFirstPass,

  131. +	kScreenshotStepSecondPass,

  132. +	kScreenshotStepSaving

  133. +};

  134. +#endif

  135. +

  136. +

  137.  struct Window::Internal {

  138.  	std::string lastWindowTitle;

  139.  

  140. -	int lastWindowX = 0;

  141. -	int lastWindowY = 0;

  142. -	int lastWindowWidth = 0;

  143. -	int lastWindowHeight = 0;

  144. +	CardinalBaseUI* ui = nullptr;

  145. +	DGL_NAMESPACE::NanoTopLevelWidget* tlw = nullptr;

  146. +	DISTRHO_NAMESPACE::WindowParameters params;

  147. +	DISTRHO_NAMESPACE::WindowParametersCallback* callback = nullptr;

  148. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  149. +	DGL_NAMESPACE::Application hiddenApp;

  150. +	DGL_NAMESPACE::Window hiddenWindow;

  151. +	NVGcontext* r_vg = nullptr;

  152. +	NVGcontext* r_fbVg = nullptr;

  153. +	NVGcontext* o_vg = nullptr;

  154. +	NVGcontext* o_fbVg = nullptr;

  155. +#endif

  156. +

  157. +	math::Vec size = WINDOW_SIZE_MIN;

  158. +

  159. +	int mods = 0;

  160. +	int currentRateLimit = 0;

  161.  

  162.  	int frame = 0;

  163. -	bool ignoreNextMouseDelta = false;

  164. -	double monitorRefreshRate = 0.0;

  165. +#ifdef CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  166. +	int generateScreenshotStep = kScreenshotStepNone;

  167. +#endif

  168. +	double monitorRefreshRate = 60.0;

  169.  	double frameTime = NAN;

  170.  	double lastFrameDuration = NAN;

  171.  

  172. -	math::Vec lastMousePos;

  173. -

  174. -	std::map<std::string, std::shared_ptr<Font>> fontCache;

  175. -	std::map<std::string, std::shared_ptr<Image>> imageCache;

  176. +	std::map<std::string, std::shared_ptr<FontWithOriginalContext>> fontCache;

  177. +	std::map<std::string, std::shared_ptr<ImageWithOriginalContext>> imageCache;

  178.  

  179.  	bool fbDirtyOnSubpixelChange = true;

  180.  	int fbCount = 0;

  181. -};

  182.  

  183. -

  184. -static void windowPosCallback(GLFWwindow* win, int x, int y) {

  185. -	if (glfwGetWindowAttrib(win, GLFW_MAXIMIZED))

  186. -		return;

  187. -	if (glfwGetWindowAttrib(win, GLFW_ICONIFIED))

  188. -		return;

  189. -	if (glfwGetWindowMonitor(win))

  190. -		return;

  191. -	settings::windowPos = math::Vec(x, y);

  192. -	// DEBUG("windowPosCallback %d %d", x, y);

  193. -}

  194. +	Internal()

  195. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  196. +		: hiddenApp(false),

  197. +		  hiddenWindow(hiddenApp, 0, DISTRHO_UI_DEFAULT_WIDTH, DISTRHO_UI_DEFAULT_HEIGHT, 0.0, true)

  198. +	{

  199. +		hiddenWindow.setIgnoringKeyRepeat(true);

  200. +		hiddenApp.idle();

  201. +	}

  202. +#else

  203. +	{}

  204. +#endif

  205. +};

  206.  

  207.  

  208. -static void windowSizeCallback(GLFWwindow* win, int width, int height) {

  209. -	if (glfwGetWindowAttrib(win, GLFW_MAXIMIZED))

  210. -		return;

  211. -	if (glfwGetWindowAttrib(win, GLFW_ICONIFIED))

  212. -		return;

  213. -	if (glfwGetWindowMonitor(win))

  214. -		return;

  215. -	settings::windowSize = math::Vec(width, height);

  216. -	// DEBUG("windowSizeCallback %d %d", width, height);

  217. -}

  218. +#ifndef DGL_NO_SHARED_RESOURCES

  219. +static int loadFallbackFont(NVGcontext* const vg)

  220. +{

  221. +	const int font = nvgFindFont(vg, NANOVG_DEJAVU_SANS_TTF);

  222. +	if (font >= 0)

  223. +		return font;

  224.  

  225. +	using namespace dpf_resources;

  226.  

  227. -static void windowMaximizeCallback(GLFWwindow* win, int maximized) {

  228. -	settings::windowMaximized = maximized;

  229. -	// DEBUG("windowMaximizeCallback %d", maximized);

  230. +	return nvgCreateFontMem(vg, NANOVG_DEJAVU_SANS_TTF,

  231. +	                        (uchar*)dejavusans_ttf, dejavusans_ttf_size, 0);

  232.  }

  233. -

  234. -

  235. -static void mouseButtonCallback(GLFWwindow* win, int button, int action, int mods) {

  236. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  237. -#if defined ARCH_MAC

  238. -	// Remap Ctrl-left click to right click on Mac

  239. -	if (button == GLFW_MOUSE_BUTTON_LEFT && (mods & RACK_MOD_MASK) == GLFW_MOD_CONTROL) {

  240. -		button = GLFW_MOUSE_BUTTON_RIGHT;

  241. -		mods &= ~GLFW_MOD_CONTROL;

  242. -	}

  243. -	// Remap Ctrl-shift-left click to middle click on Mac

  244. -	if (button == GLFW_MOUSE_BUTTON_LEFT && (mods & RACK_MOD_MASK) == (GLFW_MOD_CONTROL | GLFW_MOD_SHIFT)) {

  245. -		button = GLFW_MOUSE_BUTTON_MIDDLE;

  246. -		mods &= ~(GLFW_MOD_CONTROL | GLFW_MOD_SHIFT);

  247. -	}

  248.  #endif

  249.  

  250. -	APP->event->handleButton(APP->window->internal->lastMousePos, button, action, mods);

  251. -}

  252. -

  253.  

  254. -static void cursorPosCallback(GLFWwindow* win, double xpos, double ypos) {

  255. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  256. -	math::Vec mousePos = math::Vec(xpos, ypos).div(APP->window->pixelRatio / APP->window->windowRatio).round();

  257. -	math::Vec mouseDelta = mousePos.minus(APP->window->internal->lastMousePos);

  258. +Window::Window() {

  259. +	internal = new Internal;

  260.  

  261. -	// Workaround for GLFW warping mouse to a different position when the cursor is locked or unlocked.

  262. -	if (APP->window->internal->ignoreNextMouseDelta) {

  263. -		APP->window->internal->ignoreNextMouseDelta = false;

  264. -		mouseDelta = math::Vec();

  265. -	}

  266. +	// Set up NanoVG

  267. +	const int nvgFlags = NVG_ANTIALIAS;

  268.  

  269. -	int cursorMode = glfwGetInputMode(win, GLFW_CURSOR);

  270. -	(void) cursorMode;

  271. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  272. +	const DGL_NAMESPACE::Window::ScopedGraphicsContext sgc(internal->hiddenWindow);

  273. +	vg = nvgCreateGL(nvgFlags);

  274. +#else

  275. +	vg = static_cast<CardinalPluginContext*>(APP)->tlw->getContext();

  276. +#endif

  277. +	DISTRHO_SAFE_ASSERT_RETURN(vg != nullptr,);

  278.  

  279. -#if defined ARCH_MAC

  280. -	// Workaround for Mac. We can't use GLFW_CURSOR_DISABLED because it's buggy, so implement it on our own.

  281. -	// This is not an ideal implementation. For example, if the user drags off the screen, the new mouse position will be clamped.

  282. -	if (cursorMode == GLFW_CURSOR_HIDDEN) {

  283. -		// CGSetLocalEventsSuppressionInterval(0.0);

  284. -		glfwSetCursorPos(win, APP->window->internal->lastMousePos.x, APP->window->internal->lastMousePos.y);

  285. -		CGAssociateMouseAndMouseCursorPosition(true);

  286. -		mousePos = APP->window->internal->lastMousePos;

  287. -	}

  288. -	// Because sometimes the cursor turns into an arrow when its position is on the boundary of the window

  289. -	glfwSetCursor(win, NULL);

  290. +#ifdef NANOVG_GLES2

  291. +	fbVg = nvgCreateSharedGLES2(vg, nvgFlags);

  292. +#else

  293. +	fbVg = nvgCreateSharedGL2(vg, nvgFlags);

  294.  #endif

  295.  

  296. -	APP->window->internal->lastMousePos = mousePos;

  297. +	// Load default Blendish font

  298. +#ifndef DGL_NO_SHARED_RESOURCES

  299. +	uiFont = std::make_shared<Font>();

  300. +	uiFont->vg = vg;

  301. +	uiFont->handle = loadFallbackFont(vg);

  302. +

  303. +	std::shared_ptr<FontWithOriginalContext> uiFont2;

  304. +	uiFont2 = std::make_shared<FontWithOriginalContext>();

  305. +	uiFont2->vg = vg;

  306. +	uiFont2->handle = loadFallbackFont(vg);

  307. +	uiFont2->ofilename = asset::system("res/fonts/DejaVuSans.ttf");

  308. +	internal->fontCache[uiFont2->ofilename] = uiFont2;

  309. +#else

  310. +	uiFont = loadFont(asset::system("res/fonts/DejaVuSans.ttf"));

  311. +#endif

  312.  

  313. -	APP->event->handleHover(mousePos, mouseDelta);

  314. +	if (uiFont != nullptr)

  315. +		bndSetFont(uiFont->handle);

  316.  

  317. -	// Keyboard/mouse MIDI driver

  318. -	int width, height;

  319. -	glfwGetWindowSize(win, &width, &height);

  320. -	math::Vec scaledPos(xpos / width, ypos / height);

  321. -	keyboard::mouseMove(scaledPos);

  322. +#ifdef DISTRHO_OS_WASM

  323. +	emscripten_lock_orientation(EMSCRIPTEN_ORIENTATION_LANDSCAPE_PRIMARY);

  324. +#endif

  325.  }

  326.  

  327. -

  328. -static void cursorEnterCallback(GLFWwindow* win, int entered) {

  329. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  330. -	if (!entered) {

  331. -		APP->event->handleLeave();

  332. +void WindowSetPluginRemote(Window* const window, NanoTopLevelWidget* const tlw)

  333. +{

  334. +	// if nanovg context failed, init only bare minimum

  335. +	if (window->vg == nullptr)

  336. +	{

  337. +		if (tlw != nullptr)

  338. +		{

  339. +			window->internal->tlw = tlw;

  340. +			window->internal->size = rack::math::Vec(tlw->getWidth(), tlw->getHeight());

  341. +		}

  342. +		else

  343. +		{

  344. +			window->internal->tlw = nullptr;

  345. +			window->internal->callback = nullptr;

  346. +		}

  347. +		return;

  348.  	}

  349. -}

  350.  

  351. -

  352. -static void scrollCallback(GLFWwindow* win, double x, double y) {

  353. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  354. -	math::Vec scrollDelta = math::Vec(x, y);

  355. -#if defined ARCH_MAC

  356. -	scrollDelta = scrollDelta.mult(10.0);

  357. +	if (tlw != nullptr)

  358. +	{

  359. +		const GLubyte* vendor = glGetString(GL_VENDOR);

  360. +		const GLubyte* renderer = glGetString(GL_RENDERER);

  361. +		const GLubyte* version = glGetString(GL_VERSION);

  362. +		INFO("Renderer: %s %s", vendor, renderer);

  363. +		INFO("OpenGL: %s", version);

  364. +

  365. +		window->internal->tlw = tlw;

  366. +		window->internal->size = rack::math::Vec(tlw->getWidth(), tlw->getHeight());

  367. +

  368. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  369. +		// Set up NanoVG

  370. +		window->internal->r_vg = tlw->getContext();

  371. +#ifdef NANOVG_GLES2

  372. +		window->internal->r_fbVg = nvgCreateSharedGLES2(window->internal->r_vg, NVG_ANTIALIAS);

  373.  #else

  374. -	scrollDelta = scrollDelta.mult(50.0);

  375. +		window->internal->r_fbVg = nvgCreateSharedGL2(window->internal->r_vg, NVG_ANTIALIAS);

  376.  #endif

  377.  

  378. -	APP->event->handleScroll(APP->window->internal->lastMousePos, scrollDelta);

  379. -}

  380. +		// swap contexts

  381. +		window->internal->o_vg = window->vg;

  382. +		window->internal->o_fbVg = window->fbVg;

  383. +		window->vg = window->internal->r_vg;

  384. +		window->fbVg = window->internal->r_fbVg;

  385. +

  386. +		// also for fonts and images

  387. +		window->uiFont->vg = window->vg;

  388. +		window->uiFont->handle = loadFallbackFont(window->vg);

  389. +		for (auto& font : window->internal->fontCache)

  390. +		{

  391. +			font.second->vg = window->vg;

  392. +			font.second->ohandle = font.second->handle;

  393. +			font.second->handle = nvgCreateFont(window->vg,

  394. +			                                    font.second->ofilename.c_str(), font.second->ofilename.c_str());

  395. +		}

  396. +		for (auto& image : window->internal->imageCache)

  397. +		{

  398. +			image.second->vg = window->vg;

  399. +			image.second->ohandle = image.second->handle;

  400. +			image.second->handle = nvgCreateImage(window->vg, image.second->ofilename.c_str(),

  401. +			                                      NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY);

  402. +		}

  403. +#endif

  404.  

  405. +		// Init settings

  406. +		WindowParametersRestore(window);

  407.  

  408. -static void charCallback(GLFWwindow* win, unsigned int codepoint) {

  409. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  410. -	if (APP->event->handleText(APP->window->internal->lastMousePos, codepoint))

  411. -		return;

  412. -}

  413. +		widget::Widget::ContextCreateEvent e = {};

  414. +		e.vg = window->vg;

  415. +		APP->scene->onContextCreate(e);

  416. +	}

  417. +	else

  418. +	{

  419. +		widget::Widget::ContextDestroyEvent e = {};

  420. +		e.vg = window->vg;

  421. +		APP->scene->onContextDestroy(e);

  422.  

  423. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  424. +		// swap contexts

  425. +		window->uiFont->vg = window->internal->o_vg;

  426. +		window->vg = window->internal->o_vg;

  427. +		window->fbVg = window->internal->o_fbVg;

  428. +		window->internal->o_vg = nullptr;

  429. +		window->internal->o_fbVg = nullptr;

  430. +

  431. +		// also for fonts and images

  432. +		window->uiFont->vg = window->vg;

  433. +		window->uiFont->handle = loadFallbackFont(window->vg);

  434. +		for (auto& font : window->internal->fontCache)

  435. +		{

  436. +			font.second->vg = window->vg;

  437. +			font.second->handle = font.second->ohandle;

  438. +			font.second->ohandle = -1;

  439. +		}

  440. +		for (auto& image : window->internal->imageCache)

  441. +		{

  442. +			image.second->vg = window->vg;

  443. +			image.second->handle = image.second->ohandle;

  444. +			image.second->ohandle = -1;

  445. +		}

  446.  

  447. -static void keyCallback(GLFWwindow* win, int key, int scancode, int action, int mods) {

  448. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  449. -	if (APP->event->handleKey(APP->window->internal->lastMousePos, key, scancode, action, mods))

  450. -		return;

  451. +#if defined NANOVG_GLES2

  452. +		nvgDeleteGLES2(window->internal->r_fbVg);

  453. +#else

  454. +		nvgDeleteGL2(window->internal->r_fbVg);

  455. +#endif

  456. +#endif

  457.  

  458. -	// Keyboard/mouse MIDI driver

  459. -	if (action == GLFW_PRESS && (mods & RACK_MOD_MASK) == 0) {

  460. -		keyboard::press(key);

  461. -	}

  462. -	if (action == GLFW_RELEASE) {

  463. -		keyboard::release(key);

  464. +		window->internal->tlw = nullptr;

  465. +		window->internal->callback = nullptr;

  466.  	}

  467.  }

  468.  

  469. -

  470. -static void dropCallback(GLFWwindow* win, int count, const char** paths) {

  471. -	contextSet((Context*) glfwGetWindowUserPointer(win));

  472. -	std::vector<std::string> pathsVec;

  473. -	for (int i = 0; i < count; i++) {

  474. -		pathsVec.push_back(paths[i]);

  475. +void WindowSetPluginUI(Window* const window, CardinalBaseUI* const ui)

  476. +{

  477. +	// if nanovg context failed, init only bare minimum

  478. +	if (window->vg == nullptr)

  479. +	{

  480. +		if (ui != nullptr)

  481. +		{

  482. +			window->internal->ui = ui;

  483. +			window->internal->size = rack::math::Vec(ui->getWidth(), ui->getHeight());

  484. +		}

  485. +		else

  486. +		{

  487. +			window->internal->ui = nullptr;

  488. +			window->internal->callback = nullptr;

  489. +		}

  490. +		return;

  491.  	}

  492. -	APP->event->handleDrop(APP->window->internal->lastMousePos, pathsVec);

  493. -}

  494. -

  495. -

  496. -static void errorCallback(int error, const char* description) {

  497. -	WARN("GLFW error %d: %s", error, description);

  498. -}

  499.  

  500. +	if (ui != nullptr)

  501. +	{

  502. +		const GLubyte* vendor = glGetString(GL_VENDOR);

  503. +		const GLubyte* renderer = glGetString(GL_RENDERER);

  504. +		const GLubyte* version = glGetString(GL_VERSION);

  505. +		INFO("Renderer: %s %s", vendor, renderer);

  506. +		INFO("OpenGL: %s", version);

  507. +

  508. +		window->internal->tlw = ui;

  509. +		window->internal->ui = ui;

  510. +		window->internal->size = rack::math::Vec(ui->getWidth(), ui->getHeight());

  511. +

  512. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  513. +		// Set up NanoVG

  514. +		window->internal->r_vg = ui->getContext();

  515. +#ifdef NANOVG_GLES2

  516. +		window->internal->r_fbVg = nvgCreateSharedGLES2(window->internal->r_vg, NVG_ANTIALIAS);

  517. +#else

  518. +		window->internal->r_fbVg = nvgCreateSharedGL2(window->internal->r_vg, NVG_ANTIALIAS);

  519. +#endif

  520.  

  521. -Window::Window() {

  522. -	internal = new Internal;

  523. -	int err;

  524. -

  525. -	// Set window hints

  526. -#if defined NANOVG_GL2

  527. -	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);

  528. -	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);

  529. -#elif defined NANOVG_GL3

  530. -	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);

  531. -	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);

  532. -	glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);

  533. -	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

  534. -#endif

  535. -	glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_TRUE);

  536. -	glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);

  537. -

  538. -#if defined ARCH_MAC

  539. -	glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);

  540. -#endif

  541. -

  542. -	// Create window

  543. -	win = glfwCreateWindow(1024, 720, "", NULL, NULL);

  544. -	if (!win) {

  545. -		osdialog_message(OSDIALOG_ERROR, OSDIALOG_OK, "Could not open GLFW window. Does your graphics card support OpenGL 2.0 or greater? If so, make sure you have the latest graphics drivers installed.");

  546. -		throw Exception("Could not create Window");

  547. -	}

  548. -

  549. -	float contentScale;

  550. -	glfwGetWindowContentScale(win, &contentScale, NULL);

  551. -	INFO("Window content scale: %f", contentScale);

  552. -

  553. -	glfwSetWindowSizeLimits(win, WINDOW_SIZE_MIN.x, WINDOW_SIZE_MIN.y, GLFW_DONT_CARE, GLFW_DONT_CARE);

  554. -	if (settings::windowSize.x > 0 && settings::windowSize.y > 0) {

  555. -		glfwSetWindowSize(win, settings::windowSize.x, settings::windowSize.y);

  556. -	}

  557. -	if (settings::windowPos.x > -32000 && settings::windowPos.y > -32000) {

  558. -		glfwSetWindowPos(win, settings::windowPos.x, settings::windowPos.y);

  559. -	}

  560. -	if (settings::windowMaximized) {

  561. -		glfwMaximizeWindow(win);

  562. -	}

  563. -	glfwShowWindow(win);

  564. -

  565. -	glfwSetWindowUserPointer(win, contextGet());

  566. -	glfwSetInputMode(win, GLFW_LOCK_KEY_MODS, 1);

  567. -

  568. -	glfwMakeContextCurrent(win);

  569. -	glfwSwapInterval(0);

  570. -	const GLFWvidmode* monitorMode = glfwGetVideoMode(glfwGetPrimaryMonitor());

  571. -	if (monitorMode->refreshRate > 0) {

  572. -		internal->monitorRefreshRate = monitorMode->refreshRate;

  573. -	}

  574. -	else {

  575. -		// Some monitors report 0Hz refresh rate for some reason, so as a workaround, assume 60Hz.

  576. -		internal->monitorRefreshRate = 60;

  577. -	}

  578. -

  579. -	// Set window callbacks

  580. -	glfwSetWindowPosCallback(win, windowPosCallback);

  581. -	glfwSetWindowSizeCallback(win, windowSizeCallback);

  582. -	glfwSetWindowMaximizeCallback(win, windowMaximizeCallback);

  583. -	glfwSetMouseButtonCallback(win, mouseButtonCallback);

  584. -	// Call this ourselves, but on every frame instead of only when the mouse moves

  585. -	// glfwSetCursorPosCallback(win, cursorPosCallback);

  586. -	glfwSetCursorEnterCallback(win, cursorEnterCallback);

  587. -	glfwSetScrollCallback(win, scrollCallback);

  588. -	glfwSetCharCallback(win, charCallback);

  589. -	glfwSetKeyCallback(win, keyCallback);

  590. -	glfwSetDropCallback(win, dropCallback);

  591. -

  592. -	// Set up GLEW

  593. -	glewExperimental = GL_TRUE;

  594. -	err = glewInit();

  595. -	if (err != GLEW_OK) {

  596. -		osdialog_message(OSDIALOG_ERROR, OSDIALOG_OK, "Could not initialize GLEW. Does your graphics card support OpenGL 2.0 or greater? If so, make sure you have the latest graphics drivers installed.");

  597. -		throw Exception("Could not initialize GLEW");

  598. -	}

  599. -

  600. -	const GLubyte* vendor = glGetString(GL_VENDOR);

  601. -	const GLubyte* renderer = glGetString(GL_RENDERER);

  602. -	const GLubyte* version = glGetString(GL_VERSION);

  603. -	INFO("Renderer: %s %s", vendor, renderer);

  604. -	INFO("OpenGL: %s", version);

  605. +		// swap contexts

  606. +		window->internal->o_vg = window->vg;

  607. +		window->internal->o_fbVg = window->fbVg;

  608. +		window->vg = window->internal->r_vg;

  609. +		window->fbVg = window->internal->r_fbVg;

  610. +

  611. +		// also for fonts and images

  612. +		window->uiFont->vg = window->vg;

  613. +		window->uiFont->handle = loadFallbackFont(window->vg);

  614. +		for (auto& font : window->internal->fontCache)

  615. +		{

  616. +			font.second->vg = window->vg;

  617. +			font.second->ohandle = font.second->handle;

  618. +			font.second->handle = nvgCreateFont(window->vg,

  619. +			                                    font.second->ofilename.c_str(), font.second->ofilename.c_str());

  620. +		}

  621. +		for (auto& image : window->internal->imageCache)

  622. +		{

  623. +			image.second->vg = window->vg;

  624. +			image.second->ohandle = image.second->handle;

  625. +			image.second->handle = nvgCreateImage(window->vg, image.second->ofilename.c_str(),

  626. +			                                      NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY);

  627. +		}

  628. +#endif

  629.  

  630. -	// GLEW generates GL error because it calls glGetString(GL_EXTENSIONS), we'll consume it here.

  631. -	glGetError();

  632. +		// Init settings

  633. +		WindowParametersRestore(window);

  634.  

  635. -	// Set up NanoVG

  636. -	int nvgFlags = NVG_ANTIALIAS;

  637. -#if defined NANOVG_GL2

  638. -	vg = nvgCreateGL2(nvgFlags);

  639. -	fbVg = nvgCreateSharedGL2(vg, nvgFlags);

  640. -#elif defined NANOVG_GL3

  641. -	vg = nvgCreateGL3(nvgFlags);

  642. -#elif defined NANOVG_GLES2

  643. -	vg = nvgCreateGLES2(nvgFlags);

  644. -#endif

  645. -	if (!vg) {

  646. -		osdialog_message(OSDIALOG_ERROR, OSDIALOG_OK, "Could not initialize NanoVG. Does your graphics card support OpenGL 2.0 or greater? If so, make sure you have the latest graphics drivers installed.");

  647. -		throw Exception("Could not initialize NanoVG");

  648. +		widget::Widget::ContextCreateEvent e = {};

  649. +		e.vg = window->vg;

  650. +		APP->scene->onContextCreate(e);

  651.  	}

  652. +	else

  653. +	{

  654. +		widget::Widget::ContextDestroyEvent e = {};

  655. +		e.vg = window->vg;

  656. +		APP->scene->onContextDestroy(e);

  657.  

  658. -	// Load default Blendish font

  659. -	uiFont = loadFont(asset::system("res/fonts/DejaVuSans.ttf"));

  660. -	bndSetFont(uiFont->handle);

  661. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  662. +		// swap contexts

  663. +		window->uiFont->vg = window->internal->o_vg;

  664. +		window->vg = window->internal->o_vg;

  665. +		window->fbVg = window->internal->o_fbVg;

  666. +		window->internal->o_vg = nullptr;

  667. +		window->internal->o_fbVg = nullptr;

  668. +

  669. +		// also for fonts and images

  670. +		window->uiFont->vg = window->vg;

  671. +		window->uiFont->handle = loadFallbackFont(window->vg);

  672. +		for (auto& font : window->internal->fontCache)

  673. +		{

  674. +			font.second->vg = window->vg;

  675. +			font.second->handle = font.second->ohandle;

  676. +			font.second->ohandle = -1;

  677. +		}

  678. +		for (auto& image : window->internal->imageCache)

  679. +		{

  680. +			image.second->vg = window->vg;

  681. +			image.second->handle = image.second->ohandle;

  682. +			image.second->ohandle = -1;

  683. +		}

  684.  

  685. -	if (APP->scene) {

  686. -		widget::Widget::ContextCreateEvent e;

  687. -		e.vg = vg;

  688. -		APP->scene->onContextCreate(e);

  689. +#if defined NANOVG_GLES2

  690. +		nvgDeleteGLES2(window->internal->r_fbVg);

  691. +#else

  692. +		nvgDeleteGL2(window->internal->r_fbVg);

  693. +#endif

  694. +#endif

  695. +

  696. +		window->internal->tlw = nullptr;

  697. +		window->internal->ui = nullptr;

  698. +		window->internal->callback = nullptr;

  699.  	}

  700.  }

  701.  

  702. +void WindowSetMods(Window* const window, const int mods)

  703. +{

  704. +	window->internal->mods = mods;

  705. +}

  706.  

  707.  Window::~Window() {

  708. -	if (APP->scene) {

  709. -		widget::Widget::ContextDestroyEvent e;

  710. -		e.vg = vg;

  711. -		APP->scene->onContextDestroy(e);

  712. -	}

  713. +	{

  714. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  715. +		DGL_NAMESPACE::Window::ScopedGraphicsContext sgc(internal->hiddenWindow);

  716. +		internal->hiddenWindow.close();

  717. +		internal->hiddenApp.idle();

  718. +#endif

  719.  

  720. -	// Fonts and Images in the cache must be deleted before the NanoVG context is deleted

  721. -	internal->fontCache.clear();

  722. -	internal->imageCache.clear();

  723. -

  724. -	// nvgDeleteClone(fbVg);

  725. -

  726. -#if defined NANOVG_GL2

  727. -	nvgDeleteGL2(vg);

  728. -	nvgDeleteGL2(fbVg);

  729. -#elif defined NANOVG_GL3

  730. -	nvgDeleteGL3(vg);

  731. -#elif defined NANOVG_GLES2

  732. -	nvgDeleteGLES2(vg);

  733. +		// Fonts and Images in the cache must be deleted before the NanoVG context is deleted

  734. +		internal->fontCache.clear();

  735. +		internal->imageCache.clear();

  736. +

  737. +		if (vg != nullptr)

  738. +		{

  739. +#if DISTRHO_PLUGIN_WANT_DIRECT_ACCESS

  740. +#if defined NANOVG_GLES2

  741. +			nvgDeleteGLES2(internal->o_fbVg != nullptr ? internal->o_fbVg : fbVg);

  742. +			nvgDeleteGLES2(internal->o_vg != nullptr ? internal->o_vg : vg);

  743. +#else

  744. +			nvgDeleteGL2(internal->o_fbVg != nullptr ? internal->o_fbVg : fbVg);

  745. +			nvgDeleteGL2(internal->o_vg != nullptr ? internal->o_vg : vg);

  746.  #endif

  747. +#else

  748. +#if defined NANOVG_GLES2

  749. +			nvgDeleteGLES2(fbVg);

  750. +#else

  751. +			nvgDeleteGL2(fbVg);

  752. +#endif

  753. +#endif

  754. +		}

  755. +	}

  756.  

  757. -	glfwDestroyWindow(win);

  758.  	delete internal;

  759.  }

  760.  

  761.  

  762.  math::Vec Window::getSize() {

  763. -	int width, height;

  764. -	glfwGetWindowSize(win, &width, &height);

  765. -	return math::Vec(width, height);

  766. +	return internal->size;

  767.  }

  768.  

  769.  

  770.  void Window::setSize(math::Vec size) {

  771.  	size = size.max(WINDOW_SIZE_MIN);

  772. -	glfwSetWindowSize(win, size.x, size.y);

  773. +	internal->size = size;

  774. +

  775. +	if (DGL_NAMESPACE::NanoTopLevelWidget* const tlw = internal->ui)

  776. +		tlw->setSize(internal->size.x, internal->size.y);

  777. +}

  778. +

  779. +void WindowSetInternalSize(rack::window::Window* const window, math::Vec size) {

  780. +	size = size.max(WINDOW_SIZE_MIN);

  781. +	window->internal->size = size;

  782.  }

  783.  

  784.  

  785.  void Window::run() {

  786.  	internal->frame = 0;

  787. -	while (!glfwWindowShouldClose(win)) {

  788. -		step();

  789. +}

  790. +

  791. +

  792. +#ifdef CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  793. +static void Window__flipBitmap(uint8_t* pixels, const int width, const int height, const int depth) {

  794. +	for (int y = 0; y < height / 2; y++) {

  795. +		const int flipY = height - y - 1;

  796. +		uint8_t tmp[width * depth];

  797. +		std::memcpy(tmp, &pixels[y * width * depth], width * depth);

  798. +		std::memmove(&pixels[y * width * depth], &pixels[flipY * width * depth], width * depth);

  799. +		std::memcpy(&pixels[flipY * width * depth], tmp, width * depth);

  800. +	}

  801. +}

  802. +

  803. +

  804. +#ifdef STBI_WRITE_NO_STDIO

  805. +static void Window__downscaleBitmap(uint8_t* pixels, int& width, int& height) {

  806. +	int targetWidth = width;

  807. +	int targetHeight = height;

  808. +	double scale = 1.0;

  809. +

  810. +	if (targetWidth > 340) {

  811. +		scale = width / 340.0;

  812. +		targetWidth = 340;

  813. +		targetHeight = height / scale;

  814. +	}

  815. +	if (targetHeight > 210) {

  816. +		scale = height / 210.0;

  817. +		targetHeight = 210;

  818. +		targetWidth = width / scale;

  819. +	}

  820. +	DISTRHO_SAFE_ASSERT_INT_RETURN(targetWidth <= 340, targetWidth,);

  821. +	DISTRHO_SAFE_ASSERT_INT_RETURN(targetHeight <= 210, targetHeight,);

  822. +

  823. +	// FIXME worst possible quality :/

  824. +	for (int y = 0; y < targetHeight; ++y) {

  825. +		const int ys = static_cast<int>(y * scale);

  826. +		for (int x = 0; x < targetWidth; ++x) {

  827. +			const int xs = static_cast<int>(x * scale);

  828. +			std::memmove(pixels + (width * y + x) * 3, pixels + (width * ys + xs) * 3, 3);

  829. +		}

  830. +	}

  831. +

  832. +	width = targetWidth;

  833. +	height = targetHeight;

  834. +}

  835. +

  836. +static void Window__writeImagePNG(void* context, void* data, int size) {

  837. +	USE_NAMESPACE_DISTRHO

  838. +	CardinalBaseUI* const ui = static_cast<CardinalBaseUI*>(context);

  839. +	if (char* const screenshot = String::asBase64(data, size).getAndReleaseBuffer()) {

  840. +		ui->setState("screenshot", screenshot);

  841. +		if (ui->remoteDetails != nullptr)

  842. +			remoteUtils::sendScreenshotToRemote(ui->remoteDetails, screenshot);

  843. +		std::free(screenshot);

  844.  	}

  845.  }

  846. +#endif

  847. +#endif

  848.  

  849.  

  850.  void Window::step() {

  851. +	if (internal->tlw == nullptr || vg == nullptr)

  852. +		return;

  853. +

  854.  	double frameTime = system::getTime();

  855.  	if (std::isfinite(internal->frameTime)) {

  856.  		internal->lastFrameDuration = frameTime - internal->frameTime;

  857. @@ -424,57 +622,52 @@

  858.  	// Make event handlers and step() have a clean NanoVG context

  859.  	nvgReset(vg);

  860.  

  861. -	bndSetFont(uiFont->handle);

  862. -

  863. -	// Poll events

  864. -	// Save and restore context because event handler set their own context based on which window they originate from.

  865. -	Context* context = contextGet();

  866. -	glfwPollEvents();

  867. -	contextSet(context);

  868. -

  869. -	// In case glfwPollEvents() sets another OpenGL context

  870. -	glfwMakeContextCurrent(win);

  871. -

  872. -	// Call cursorPosCallback every frame, not just when the mouse moves

  873. -	{

  874. -		double xpos, ypos;

  875. -		glfwGetCursorPos(win, &xpos, &ypos);

  876. -		cursorPosCallback(win, xpos, ypos);

  877. -	}

  878. -	gamepad::step();

  879. +	if (uiFont != nullptr)

  880. +		bndSetFont(uiFont->handle);

  881.  

  882.  	// Set window title

  883. -	std::string windowTitle = APP_NAME + " " + APP_EDITION_NAME + " " + APP_VERSION;

  884. -	if (APP->patch->path != "") {

  885. -		windowTitle += " - ";

  886. -		if (!APP->history->isSaved())

  887. -			windowTitle += "*";

  888. -		windowTitle += system::getFilename(APP->patch->path);

  889. -	}

  890. -	if (windowTitle != internal->lastWindowTitle) {

  891. -		glfwSetWindowTitle(win, windowTitle.c_str());

  892. -		internal->lastWindowTitle = windowTitle;

  893. +	if (isStandalone()) {

  894. +#if CARDINAL_VARIANT_MINI

  895. +		std::string windowTitle = "Cardinal Mini";

  896. +#else

  897. +		std::string windowTitle = "Cardinal";

  898. +#endif

  899. +		if (APP->patch->path != "") {

  900. +			windowTitle += " - ";

  901. +			if (!APP->history->isSaved())

  902. +				windowTitle += "*";

  903. +			windowTitle += system::getFilename(APP->patch->path);

  904. +		}

  905. +		if (windowTitle != internal->lastWindowTitle) {

  906. +			internal->tlw->getWindow().setTitle(windowTitle.c_str());

  907. +			internal->lastWindowTitle = windowTitle;

  908. +		}

  909.  	}

  910.  

  911.  	// Get desired pixel ratio

  912. -	float newPixelRatio;

  913. -	if (settings::pixelRatio > 0.0) {

  914. -		newPixelRatio = settings::pixelRatio;

  915. -	}

  916. -	else {

  917. -		glfwGetWindowContentScale(win, &newPixelRatio, NULL);

  918. -		newPixelRatio = std::floor(newPixelRatio + 0.5);

  919. -	}

  920. +	float newPixelRatio = internal->tlw->getScaleFactor();

  921.  	if (newPixelRatio != pixelRatio) {

  922.  		pixelRatio = newPixelRatio;

  923.  		APP->event->handleDirty();

  924.  	}

  925.  

  926. +#ifdef CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  927. +	// Hide menu and background if generating screenshot

  928. +	if (internal->generateScreenshotStep == kScreenshotStepStarted) {

  929. +#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS

  930. +		APP->scene->menuBar->hide();

  931. +		APP->scene->rack->children.front()->hide();

  932. +#else

  933. +		internal->generateScreenshotStep = kScreenshotStepSecondPass;

  934. +#endif

  935. +	}

  936. +#endif

  937. +

  938.  	// Get framebuffer/window ratio

  939. -	int fbWidth, fbHeight;

  940. -	glfwGetFramebufferSize(win, &fbWidth, &fbHeight);

  941. -	int winWidth, winHeight;

  942. -	glfwGetWindowSize(win, &winWidth, &winHeight);

  943. +	int winWidth = internal->tlw->getWidth();

  944. +	int winHeight = internal->tlw->getHeight();

  945. +	int fbWidth = winWidth;

  946. +	int fbHeight = winHeight;

  947.  	windowRatio = (float)fbWidth / winWidth;

  948.  	// t1 = system::getTime();

  949.  

  950. @@ -488,10 +681,8 @@

  951.  		// t2 = system::getTime();

  952.  

  953.  		// Render scene

  954. -		bool visible = glfwGetWindowAttrib(win, GLFW_VISIBLE) && !glfwGetWindowAttrib(win, GLFW_ICONIFIED);

  955. -		if (visible) {

  956. +		{

  957.  			// Update and render

  958. -			nvgBeginFrame(vg, fbWidth, fbHeight, pixelRatio);

  959.  			nvgScale(vg, pixelRatio, pixelRatio);

  960.  

  961.  			// Draw scene

  962. @@ -502,23 +693,16 @@

  963.  			// t3 = system::getTime();

  964.  

  965.  			glViewport(0, 0, fbWidth, fbHeight);

  966. +#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS

  967. +			glClearColor(0.0, 0.0, 0.0, 0.0);

  968. +#else

  969.  			glClearColor(0.0, 0.0, 0.0, 1.0);

  970. +#endif

  971.  			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

  972. -			nvgEndFrame(vg);

  973.  		}

  974.  		// t4 = system::getTime();

  975.  	}

  976.  

  977. -	glfwSwapBuffers(win);

  978. -

  979. -	// Limit frame rate

  980. -	if (settings::frameRateLimit > 0) {

  981. -		double remaining = getFrameDurationRemaining();

  982. -		if (remaining > 0.0) {

  983. -			system::sleep(remaining);

  984. -		}

  985. -	}

  986. -

  987.  	// t5 = system::getTime();

  988.  	// DEBUG("pre-step %6.1f step %6.1f draw %6.1f nvgEndFrame %6.1f glfwSwapBuffers %6.1f total %6.1f",

  989.  	// 	(t1 - frameTime) * 1e3f,

  990. @@ -528,168 +712,132 @@

  991.  	// 	(t5 - t4) * 1e3f,

  992.  	// 	(t5 - frameTime) * 1e3f

  993.  	// );

  994. -	internal->frame++;

  995. -}

  996. +	++internal->frame;

  997. +

  998. +#ifdef CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  999. +	if (internal->generateScreenshotStep != kScreenshotStepNone) {

  1000. +		++internal->generateScreenshotStep;

  1001. +

  1002. +		int y = 0;

  1003. +#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS

  1004. +		constexpr const int depth = 4;

  1005. +#else

  1006. +		y = APP->scene->menuBar->box.size.y * newPixelRatio;

  1007. +		constexpr const int depth = 3;

  1008. +#endif

  1009.  

  1010. +		// Allocate pixel color buffer

  1011. +		uint8_t* const pixels = new uint8_t[winHeight * winWidth * 4];

  1012.  

  1013. -static void flipBitmap(uint8_t* pixels, int width, int height, int depth) {

  1014. -	for (int y = 0; y < height / 2; y++) {

  1015. -		int flipY = height - y - 1;

  1016. -		uint8_t tmp[width * depth];

  1017. -		std::memcpy(tmp, &pixels[y * width * depth], width * depth);

  1018. -		std::memcpy(&pixels[y * width * depth], &pixels[flipY * width * depth], width * depth);

  1019. -		std::memcpy(&pixels[flipY * width * depth], tmp, width * depth);

  1020. +		// glReadPixels defaults to GL_BACK, but the back-buffer is unstable, so use the front buffer (what the user sees)

  1021. +		glReadBuffer(GL_FRONT);

  1022. +		glReadPixels(0, 0, winWidth, winHeight, depth == 3 ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, pixels);

  1023. +

  1024. +		if (internal->generateScreenshotStep == kScreenshotStepSaving)

  1025. +		{

  1026. +			// Write pixels to PNG

  1027. +			Window__flipBitmap(pixels, winWidth, winHeight, depth);

  1028. +			winHeight -= y;

  1029. +			const int stride = winWidth * depth;

  1030. +			uint8_t* const pixelsWithOffset = pixels + (stride * y);

  1031. +#ifdef STBI_WRITE_NO_STDIO

  1032. +			Window__downscaleBitmap(pixelsWithOffset, winWidth, winHeight);

  1033. +			stbi_write_png_to_func(Window__writeImagePNG, internal->ui,

  1034. +			                       winWidth, winHeight, depth, pixelsWithOffset, stride);

  1035. +#else

  1036. +			stbi_write_png("screenshot.png", winWidth, winHeight, depth, pixelsWithOffset, stride);

  1037. +#endif

  1038. +

  1039. +			internal->generateScreenshotStep = kScreenshotStepNone;

  1040. +#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS

  1041. +			APP->scene->menuBar->show();

  1042. +			APP->scene->rack->children.front()->show();

  1043. +#endif

  1044. +		}

  1045. +

  1046. +		delete[] pixels;

  1047.  	}

  1048. +#endif

  1049.  }

  1050.  

  1051.  

  1052.  void Window::screenshot(const std::string& screenshotPath) {

  1053. -	// Get window framebuffer size

  1054. -	int width, height;

  1055. -	glfwGetFramebufferSize(APP->window->win, &width, &height);

  1056. -

  1057. -	// Allocate pixel color buffer

  1058. -	uint8_t* pixels = new uint8_t[height * width * 4];

  1059. -

  1060. -	// glReadPixels defaults to GL_BACK, but the back-buffer is unstable, so use the front buffer (what the user sees)

  1061. -	glReadBuffer(GL_FRONT);

  1062. -	glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

  1063. -

  1064. -	// Write pixels to PNG

  1065. -	flipBitmap(pixels, width, height, 4);

  1066. -	stbi_write_png(screenshotPath.c_str(), width, height, 4, pixels, width * 4);

  1067. -

  1068. -	delete[] pixels;

  1069.  }

  1070.  

  1071.  

  1072.  void Window::screenshotModules(const std::string& screenshotsDir, float zoom) {

  1073. -	// Disable preferDarkPanels

  1074. -	bool preferDarkPanels = settings::preferDarkPanels;

  1075. -	settings::preferDarkPanels = false;

  1076. -	DEFER({settings::preferDarkPanels = preferDarkPanels;});

  1077. -

  1078. -	// Iterate plugins and create directories

  1079. -	system::createDirectories(screenshotsDir);

  1080. -	for (plugin::Plugin* p : plugin::plugins) {

  1081. -		std::string dir = system::join(screenshotsDir, p->slug);

  1082. -		system::createDirectory(dir);

  1083. -		for (plugin::Model* model : p->models) {

  1084. -			std::string filename = system::join(dir, model->slug + ".png");

  1085. -

  1086. -			// Skip model if screenshot already exists

  1087. -			if (system::isFile(filename))

  1088. -				continue;

  1089. -

  1090. -			INFO("Screenshotting %s %s to %s", p->slug.c_str(), model->slug.c_str(), filename.c_str());

  1091. -

  1092. -			// Create widgets

  1093. -			widget::FramebufferWidget* fbw = new widget::FramebufferWidget;

  1094. -			fbw->oversample = 2;

  1095. -

  1096. -			struct ModuleWidgetContainer : widget::Widget {

  1097. -				void draw(const DrawArgs& args) override {

  1098. -					Widget::draw(args);

  1099. -					Widget::drawLayer(args, 1);

  1100. -				}

  1101. -			};

  1102. -			ModuleWidgetContainer* mwc = new ModuleWidgetContainer;

  1103. -			fbw->addChild(mwc);

  1104. -

  1105. -			app::ModuleWidget* mw = model->createModuleWidget(NULL);

  1106. -			mwc->box.size = mw->box.size;

  1107. -			fbw->box.size = mw->box.size;

  1108. -			mwc->addChild(mw);

  1109. -

  1110. -			// Step to allow the ModuleWidget state to set its default appearance.

  1111. -			fbw->step();

  1112. -

  1113. -			// Draw to framebuffer

  1114. -			fbw->render(math::Vec(zoom, zoom));

  1115. -

  1116. -			// Read pixels

  1117. -			nvgluBindFramebuffer(fbw->getFramebuffer());

  1118. -			int width, height;

  1119. -			nvgImageSize(vg, fbw->getImageHandle(), &width, &height);

  1120. -			uint8_t* pixels = new uint8_t[height * width * 4];

  1121. -			glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);

  1122. -

  1123. -			// Write pixels to PNG

  1124. -			flipBitmap(pixels, width, height, 4);

  1125. -			stbi_write_png(filename.c_str(), width, height, 4, pixels, width * 4);

  1126. -

  1127. -			// Cleanup

  1128. -			delete[] pixels;

  1129. -			nvgluBindFramebuffer(NULL);

  1130. -			delete fbw;

  1131. -		}

  1132. -	}

  1133.  }

  1134.  

  1135.  

  1136.  void Window::close() {

  1137. -	glfwSetWindowShouldClose(win, GLFW_TRUE);

  1138. +	DISTRHO_SAFE_ASSERT_RETURN(internal->tlw != nullptr,);

  1139. +

  1140. +	internal->tlw->getWindow().close();

  1141.  }

  1142.  

  1143.  

  1144.  void Window::cursorLock() {

  1145. +#ifdef DISTRHO_OS_WASM

  1146.  	if (!settings::allowCursorLock)

  1147.  		return;

  1148.  

  1149. -#if defined ARCH_MAC

  1150. -	glfwSetInputMode(win, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);

  1151. -#else

  1152. -	glfwSetInputMode(win, GLFW_CURSOR, GLFW_CURSOR_DISABLED);

  1153. +	emscripten_request_pointerlock(internal->tlw->getWindow().getApp().getClassName(), false);

  1154.  #endif

  1155. -	internal->ignoreNextMouseDelta = true;

  1156.  }

  1157.  

  1158.  

  1159.  void Window::cursorUnlock() {

  1160. +#ifdef DISTRHO_OS_WASM

  1161.  	if (!settings::allowCursorLock)

  1162.  		return;

  1163.  

  1164. -	glfwSetInputMode(win, GLFW_CURSOR, GLFW_CURSOR_NORMAL);

  1165. -	internal->ignoreNextMouseDelta = true;

  1166. +	emscripten_exit_pointerlock();

  1167. +#endif

  1168.  }

  1169.  

  1170.  

  1171.  bool Window::isCursorLocked() {

  1172. -	return glfwGetInputMode(win, GLFW_CURSOR) != GLFW_CURSOR_NORMAL;

  1173. +#ifdef DISTRHO_OS_WASM

  1174. +	EmscriptenPointerlockChangeEvent status;

  1175. +	if (emscripten_get_pointerlock_status(&status) == EMSCRIPTEN_RESULT_SUCCESS)

  1176. +		return status.isActive;

  1177. +#endif

  1178. +	return false;

  1179.  }

  1180.  

  1181.  

  1182.  int Window::getMods() {

  1183. -	int mods = 0;

  1184. -	if (glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS)

  1185. -		mods |= GLFW_MOD_SHIFT;

  1186. -	if (glfwGetKey(win, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS)

  1187. -		mods |= GLFW_MOD_CONTROL;

  1188. -	if (glfwGetKey(win, GLFW_KEY_LEFT_ALT) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_ALT) == GLFW_PRESS)

  1189. -		mods |= GLFW_MOD_ALT;

  1190. -	if (glfwGetKey(win, GLFW_KEY_LEFT_SUPER) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_SUPER) == GLFW_PRESS)

  1191. -		mods |= GLFW_MOD_SUPER;

  1192. -	return mods;

  1193. +	return internal->mods;

  1194.  }

  1195.  

  1196.  

  1197.  void Window::setFullScreen(bool fullScreen) {

  1198. -	if (!fullScreen) {

  1199. -		glfwSetWindowMonitor(win, NULL, internal->lastWindowX, internal->lastWindowY, internal->lastWindowWidth, internal->lastWindowHeight, GLFW_DONT_CARE);

  1200. +#ifdef DISTRHO_OS_WASM

  1201. +	if (fullScreen)

  1202. +	{

  1203. +		try {

  1204. +			emscripten_request_fullscreen(internal->tlw->getWindow().getApp().getClassName(), false);

  1205. +		} DISTRHO_SAFE_EXCEPTION("fullscreen");

  1206.  	}

  1207. -	else {

  1208. -		glfwGetWindowPos(win, &internal->lastWindowX, &internal->lastWindowY);

  1209. -		glfwGetWindowSize(win, &internal->lastWindowWidth, &internal->lastWindowHeight);

  1210. -		GLFWmonitor* monitor = glfwGetPrimaryMonitor();

  1211. -		const GLFWvidmode* mode = glfwGetVideoMode(monitor);

  1212. -		glfwSetWindowMonitor(win, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);

  1213. +	else

  1214. +	{

  1215. +		emscripten_exit_fullscreen();

  1216.  	}

  1217. +#endif

  1218.  }

  1219.  

  1220.  

  1221.  bool Window::isFullScreen() {

  1222. -	GLFWmonitor* monitor = glfwGetWindowMonitor(win);

  1223. -	return monitor != NULL;

  1224. +#ifdef DISTRHO_OS_WASM

  1225. +	EmscriptenFullscreenChangeEvent status;

  1226. +	if (emscripten_get_fullscreen_status(&status) == EMSCRIPTEN_RESULT_SUCCESS)

  1227. +		return status.isFullscreen;

  1228. +	return false;

  1229. +#elif defined(CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS) && defined(CARDINAL_TRANSPARENT_SCREENSHOTS)

  1230. +	return internal->generateScreenshotStep != kScreenshotStepNone;

  1231. +#else

  1232. +	return false;

  1233. +#endif

  1234.  }

  1235.  

  1236.  

  1237. @@ -709,7 +857,7 @@

  1238.  

  1239.  

  1240.  double Window::getFrameDurationRemaining() {

  1241. -	double frameDuration = 1.f / settings::frameRateLimit;

  1242. +	double frameDuration = 1.f / internal->monitorRefreshRate;

  1243.  	return frameDuration - (system::getTime() - internal->frameTime);

  1244.  }

  1245.  

  1246. @@ -720,14 +868,15 @@

  1247.  		return pair->second;

  1248.  

  1249.  	// Load font

  1250. -	std::shared_ptr<Font> font;

  1251. +	std::shared_ptr<FontWithOriginalContext> font;

  1252.  	try {

  1253. -		font = std::make_shared<Font>();

  1254. +		font = std::make_shared<FontWithOriginalContext>();

  1255. +		font->ofilename = filename;

  1256.  		font->loadFile(filename, vg);

  1257.  	}

  1258.  	catch (Exception& e) {

  1259.  		WARN("%s", e.what());

  1260. -		font = NULL;

  1261. +		font = nullptr;

  1262.  	}

  1263.  	internal->fontCache[filename] = font;

  1264.  	return font;

  1265. @@ -740,14 +889,15 @@

  1266.  		return pair->second;

  1267.  

  1268.  	// Load image

  1269. -	std::shared_ptr<Image> image;

  1270. +	std::shared_ptr<ImageWithOriginalContext> image;

  1271.  	try {

  1272. -		image = std::make_shared<Image>();

  1273. +		image = std::make_shared<ImageWithOriginalContext>();

  1274. +		image->ofilename = filename;

  1275.  		image->loadFile(filename, vg);

  1276.  	}

  1277.  	catch (Exception& e) {

  1278.  		WARN("%s", e.what());

  1279. -		image = NULL;

  1280. +		image = nullptr;

  1281.  	}

  1282.  	internal->imageCache[filename] = image;

  1283.  	return image;

  1284. @@ -764,28 +914,156 @@

  1285.  }

  1286.  

  1287.  

  1288. -void init() {

  1289. -	int err;

  1290. -

  1291. -	// Set up GLFW

  1292. -#if defined ARCH_MAC

  1293. -	glfwInitHint(GLFW_COCOA_CHDIR_RESOURCES, GLFW_TRUE);

  1294. -	glfwInitHint(GLFW_COCOA_MENUBAR, GLFW_FALSE);

  1295. +void generateScreenshot() {

  1296. +#ifdef CARDINAL_WINDOW_CAN_GENERATE_SCREENSHOTS

  1297. +	APP->window->internal->generateScreenshotStep = kScreenshotStepStarted;

  1298.  #endif

  1299. +}

  1300.  

  1301. -	glfwSetErrorCallback(errorCallback);

  1302. -	err = glfwInit();

  1303. -	if (err != GLFW_TRUE) {

  1304. -		osdialog_message(OSDIALOG_ERROR, OSDIALOG_OK, "Could not initialize GLFW.");

  1305. -		throw Exception("Could not initialize GLFW");

  1306. -	}

  1307. +

  1308. +void init() {

  1309.  }

  1310.  

  1311.  

  1312.  void destroy() {

  1313. -	glfwTerminate();

  1314.  }

  1315.  

  1316.  

  1317.  } // namespace window

  1318.  } // namespace rack

  1319. +

  1320. +

  1321. +START_NAMESPACE_DISTRHO

  1322. +

  1323. +void WindowParametersSave(rack::window::Window* const window)

  1324. +{

  1325. +	if (d_isNotEqual(window->internal->params.cableOpacity, rack::settings::cableOpacity))

  1326. +	{

  1327. +		window->internal->params.cableOpacity = rack::settings::cableOpacity;

  1328. +		if (window->internal->callback != nullptr)

  1329. +			window->internal->callback->WindowParametersChanged(kWindowParameterCableOpacity,

  1330. +			                                                    rack::settings::cableOpacity);

  1331. +	}

  1332. +	if (d_isNotEqual(window->internal->params.cableTension, rack::settings::cableTension))

  1333. +	{

  1334. +		window->internal->params.cableTension = rack::settings::cableTension;

  1335. +		if (window->internal->callback != nullptr)

  1336. +			window->internal->callback->WindowParametersChanged(kWindowParameterCableTension,

  1337. +			                                                    rack::settings::cableTension);

  1338. +	}

  1339. +	if (d_isNotEqual(window->internal->params.rackBrightness, rack::settings::rackBrightness))

  1340. +	{

  1341. +		window->internal->params.rackBrightness = rack::settings::rackBrightness;

  1342. +		if (window->internal->callback != nullptr)

  1343. +			window->internal->callback->WindowParametersChanged(kWindowParameterRackBrightness,

  1344. +			                                                    rack::settings::rackBrightness);

  1345. +	}

  1346. +	if (d_isNotEqual(window->internal->params.haloBrightness, rack::settings::haloBrightness))

  1347. +	{

  1348. +		window->internal->params.haloBrightness = rack::settings::haloBrightness;

  1349. +		if (window->internal->callback != nullptr)

  1350. +			window->internal->callback->WindowParametersChanged(kWindowParameterHaloBrightness,

  1351. +			                                                    rack::settings::haloBrightness);

  1352. +	}

  1353. +	if (d_isNotEqual(window->internal->params.knobScrollSensitivity, rack::settings::knobScrollSensitivity))

  1354. +	{

  1355. +		window->internal->params.knobScrollSensitivity = rack::settings::knobScrollSensitivity;

  1356. +		if (window->internal->callback != nullptr)

  1357. +			window->internal->callback->WindowParametersChanged(kWindowParameterWheelSensitivity,

  1358. +			                                                    rack::settings::knobScrollSensitivity);

  1359. +	}

  1360. +	if (d_isNotEqual(window->internal->params.browserZoom, rack::settings::browserZoom))

  1361. +	{

  1362. +		window->internal->params.browserZoom = rack::settings::browserZoom;

  1363. +		if (window->internal->callback != nullptr)

  1364. +			window->internal->callback->WindowParametersChanged(kWindowParameterBrowserZoom,

  1365. +			                                                    rack::settings::browserZoom);

  1366. +	}

  1367. +	if (window->internal->params.knobMode != rack::settings::knobMode)

  1368. +	{

  1369. +		window->internal->params.knobMode = rack::settings::knobMode;

  1370. +		if (window->internal->callback != nullptr)

  1371. +			window->internal->callback->WindowParametersChanged(kWindowParameterKnobMode,

  1372. +			                                                    rack::settings::knobMode);

  1373. +	}

  1374. +	if (window->internal->params.browserSort != rack::settings::browserSort)

  1375. +	{

  1376. +		window->internal->params.browserSort = rack::settings::browserSort;

  1377. +		if (window->internal->callback != nullptr)

  1378. +			window->internal->callback->WindowParametersChanged(kWindowParameterBrowserSort,

  1379. +			                                                    rack::settings::browserSort);

  1380. +	}

  1381. +	if (window->internal->params.tooltips != rack::settings::tooltips)

  1382. +	{

  1383. +		window->internal->params.tooltips = rack::settings::tooltips;

  1384. +		if (window->internal->callback != nullptr)

  1385. +			window->internal->callback->WindowParametersChanged(kWindowParameterShowTooltips,

  1386. +			                                                    rack::settings::tooltips);

  1387. +	}

  1388. +	if (window->internal->params.knobScroll != rack::settings::knobScroll)

  1389. +	{

  1390. +		window->internal->params.knobScroll = rack::settings::knobScroll;

  1391. +		if (window->internal->callback != nullptr)

  1392. +			window->internal->callback->WindowParametersChanged(kWindowParameterWheelKnobControl,

  1393. +			                                                    rack::settings::knobScroll);

  1394. +	}

  1395. +	if (window->internal->params.lockModules != rack::settings::lockModules)

  1396. +	{

  1397. +		window->internal->params.lockModules = rack::settings::lockModules;

  1398. +		if (window->internal->callback != nullptr)

  1399. +			window->internal->callback->WindowParametersChanged(kWindowParameterLockModulePositions,

  1400. +			                                                    rack::settings::lockModules);

  1401. +	}

  1402. +	if (window->internal->params.squeezeModules != rack::settings::squeezeModules)

  1403. +	{

  1404. +		window->internal->params.squeezeModules = rack::settings::squeezeModules;

  1405. +		if (window->internal->callback != nullptr)

  1406. +			window->internal->callback->WindowParametersChanged(kWindowParameterSqueezeModulePositions,

  1407. +			                                                    rack::settings::squeezeModules);

  1408. +	}

  1409. +	if (window->internal->params.invertZoom != rack::settings::invertZoom)

  1410. +	{

  1411. +		window->internal->params.invertZoom = rack::settings::invertZoom;

  1412. +		if (window->internal->callback != nullptr)

  1413. +			window->internal->callback->WindowParametersChanged(kWindowParameterInvertZoom,

  1414. +			                                                    rack::settings::invertZoom);

  1415. +	}

  1416. +	if (window->internal->params.rateLimit != rack::settings::rateLimit)

  1417. +	{

  1418. +		window->internal->params.rateLimit = rack::settings::rateLimit;

  1419. +		if (window->internal->callback != nullptr)

  1420. +			window->internal->callback->WindowParametersChanged(kWindowParameterUpdateRateLimit,

  1421. +			                                                    rack::settings::rateLimit);

  1422. +	}

  1423. +}

  1424. +

  1425. +void WindowParametersRestore(rack::window::Window* const window)

  1426. +{

  1427. +	rack::settings::cableOpacity = window->internal->params.cableOpacity;

  1428. +	rack::settings::cableTension = window->internal->params.cableTension;

  1429. +	rack::settings::rackBrightness = window->internal->params.rackBrightness;

  1430. +	rack::settings::haloBrightness = window->internal->params.haloBrightness;

  1431. +	rack::settings::knobScrollSensitivity = window->internal->params.knobScrollSensitivity;

  1432. +	rack::settings::browserZoom = window->internal->params.browserZoom;

  1433. +	rack::settings::knobMode = static_cast<rack::settings::KnobMode>(window->internal->params.knobMode);

  1434. +	rack::settings::browserSort = static_cast<rack::settings::BrowserSort>(window->internal->params.browserSort);

  1435. +	rack::settings::tooltips = window->internal->params.tooltips;

  1436. +	rack::settings::knobScroll = window->internal->params.knobScroll;

  1437. +	rack::settings::lockModules = window->internal->params.lockModules;

  1438. +	rack::settings::squeezeModules = window->internal->params.squeezeModules;

  1439. +	rack::settings::invertZoom = window->internal->params.invertZoom;

  1440. +	rack::settings::rateLimit = window->internal->params.rateLimit;

  1441. +}

  1442. +

  1443. +void WindowParametersSetCallback(rack::window::Window* const window, WindowParametersCallback* const callback)

  1444. +{

  1445. +	window->internal->callback = callback;

  1446. +}

  1447. +

  1448. +void WindowParametersSetValues(rack::window::Window* const window, const WindowParameters& params)

  1449. +{

  1450. +	window->internal->params = params;

  1451. +}

  1452. +

  1453. +END_NAMESPACE_DISTRHO

  1454. +