brian/Cardinal
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
Cardinal/src/override/diffs/Window.cpp.diff
falkTX 310cab2d6d Store a few more properties as plugin state, including favorites 
Signed-off-by: falkTX <falktx@falktx.com>
2022-04-27 18:17:16 +01:00

1232 lines
40 KiB
Diff
Raw Blame History

--- ../Rack/src/window/Window.cpp 2022-02-09 15:35:19.238863170 +0000
+++ Window.cpp 2022-04-27 16:53:59.743671091 +0100
@@ -1,33 +1,83 @@
+/*
+ * DISTRHO Cardinal Plugin
+ * Copyright (C) 2021-2022 Filipe Coelho <falktx@falktx.com>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of
+ * the License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * For a full copy of the GNU General Public License see the LICENSE file.
+ */
+
+/**
+ * This file is an edited version of VCVRack's window/Window.cpp
+ * Copyright (C) 2016-2021 VCV.
+ *
+ * This program is free software: you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 3 of
+ * the License, or (at your option) any later version.
+ */
+
#include <map>
#include <queue>
#include <thread>
-#if defined ARCH_MAC
- // For CGAssociateMouseAndMouseCursorPosition
- #include <ApplicationServices/ApplicationServices.h>
-#endif
-
-#include <stb_image_write.h>
-#include <osdialog.h>
-
#include <window/Window.hpp>
#include <asset.hpp>
#include <widget/Widget.hpp>
#include <app/Scene.hpp>
-#include <keyboard.hpp>
-#include <gamepad.hpp>
#include <context.hpp>
#include <patch.hpp>
#include <settings.hpp>
-#include <plugin.hpp> // used in Window::screenshot
-#include <system.hpp> // used in Window::screenshot
+#include <system.hpp>
+
+#ifdef NDEBUG
+# undef DEBUG
+#endif
+
+// comment out if wanting to generate a local screenshot.png
+#define STBI_WRITE_NO_STDIO
+// uncomment to generate screenshots without the rack rail background (ie, transparent)
+// #define CARDINAL_TRANSPARENT_SCREENSHOTS
+
+// used in Window::screenshot
+#define STB_IMAGE_WRITE_IMPLEMENTATION
+#include "stb_image_write.h"
+
+#include "DistrhoUI.hpp"
+#include "Application.hpp"
+#include "extra/String.hpp"
+#include "../CardinalCommon.hpp"
+#include "../WindowParameters.hpp"
+
+#ifndef DGL_NO_SHARED_RESOURCES
+# include "src/Resources.hpp"
+#endif
namespace rack {
namespace window {
-static const math::Vec WINDOW_SIZE_MIN = math::Vec(480, 320);
+static const math::Vec WINDOW_SIZE_MIN = math::Vec(648, 538);
+
+
+struct FontWithOriginalContext : Font {
+ int ohandle = -1;
+ std::string ofilename;
+};
+
+struct ImageWithOriginalContext : Image {
+ int ohandle = -1;
+ std::string ofilename;
+};
Font::~Font() {
@@ -42,9 +92,8 @@
// Transfer ownership of font data to font object
uint8_t* data = system::readFile(filename, &size);
// Don't use nvgCreateFont because it doesn't properly handle UTF-8 filenames on Windows.
- handle = nvgCreateFontMem(vg, name.c_str(), data, size, 0);
+ handle = nvgCreateFontMem(vg, name.c_str(), data, size, 1);
if (handle < 0) {
- std::free(data);
throw Exception("Failed to load font %s", filename.c_str());
}
INFO("Loaded font %s", filename.c_str());
@@ -79,375 +128,308 @@
}
+enum ScreenshotStep {
+ kScreenshotStepNone,
+ kScreenshotStepStarted,
+ kScreenshotStepFirstPass,
+ kScreenshotStepSecondPass,
+ kScreenshotStepSaving
+};
+
+
struct Window::Internal {
std::string lastWindowTitle;
- int lastWindowX = 0;
- int lastWindowY = 0;
- int lastWindowWidth = 0;
- int lastWindowHeight = 0;
+ DISTRHO_NAMESPACE::UI* ui = nullptr;
+ DISTRHO_NAMESPACE::WindowParameters params;
+ DISTRHO_NAMESPACE::WindowParametersCallback* callback = nullptr;
+ DGL_NAMESPACE::Application hiddenApp;
+ DGL_NAMESPACE::Window hiddenWindow;
+ NVGcontext* r_vg = nullptr;
+ NVGcontext* r_fbVg = nullptr;
+ NVGcontext* o_vg = nullptr;
+ NVGcontext* o_fbVg = nullptr;
+
+ math::Vec size = WINDOW_SIZE_MIN;
+
+ int mods = 0;
+ int currentRateLimit = 0;
int frame = 0;
- bool ignoreNextMouseDelta = false;
- int frameSwapInterval = -1;
- double monitorRefreshRate = 0.0;
+ int frameSwapInterval = 1;
+ int generateScreenshotStep = kScreenshotStepNone;
+ double monitorRefreshRate = 60.0;
double frameTime = 0.0;
double lastFrameDuration = 0.0;
- math::Vec lastMousePos;
-
- std::map<std::string, std::shared_ptr<Font>> fontCache;
- std::map<std::string, std::shared_ptr<Image>> imageCache;
+ std::map<std::string, std::shared_ptr<FontWithOriginalContext>> fontCache;
+ std::map<std::string, std::shared_ptr<ImageWithOriginalContext>> imageCache;
bool fbDirtyOnSubpixelChange = true;
int fbCount = 0;
+
+ Internal()
+ : hiddenApp(false),
+ hiddenWindow(hiddenApp) { hiddenApp.idle(); }
};
-static void windowPosCallback(GLFWwindow* win, int x, int y) {
- if (glfwGetWindowAttrib(win, GLFW_MAXIMIZED))
- return;
- if (glfwGetWindowAttrib(win, GLFW_ICONIFIED))
- return;
- if (glfwGetWindowMonitor(win))
- return;
- settings::windowPos = math::Vec(x, y);
- // DEBUG("windowPosCallback %d %d", x, y);
-}
+#ifndef DGL_NO_SHARED_RESOURCES
+static int loadFallbackFont(NVGcontext* const vg)
+{
+ const int font = nvgFindFont(vg, NANOVG_DEJAVU_SANS_TTF);
+ if (font >= 0)
+ return font;
+ using namespace dpf_resources;
-static void windowSizeCallback(GLFWwindow* win, int width, int height) {
- if (glfwGetWindowAttrib(win, GLFW_MAXIMIZED))
- return;
- if (glfwGetWindowAttrib(win, GLFW_ICONIFIED))
- return;
- if (glfwGetWindowMonitor(win))
- return;
- settings::windowSize = math::Vec(width, height);
- // DEBUG("windowSizeCallback %d %d", width, height);
+ return nvgCreateFontMem(vg, NANOVG_DEJAVU_SANS_TTF,
+ (uchar*)dejavusans_ttf, dejavusans_ttf_size, 0);
}
-
-
-static void windowMaximizeCallback(GLFWwindow* win, int maximized) {
- settings::windowMaximized = maximized;
- // DEBUG("windowMaximizeCallback %d", maximized);
-}
-
-
-static void mouseButtonCallback(GLFWwindow* win, int button, int action, int mods) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
-#if defined ARCH_MAC
- // Remap Ctrl-left click to right click on Mac
- if (button == GLFW_MOUSE_BUTTON_LEFT && (mods & RACK_MOD_MASK) == GLFW_MOD_CONTROL) {
- button = GLFW_MOUSE_BUTTON_RIGHT;
- mods &= ~GLFW_MOD_CONTROL;
- }
- // Remap Ctrl-shift-left click to middle click on Mac
- if (button == GLFW_MOUSE_BUTTON_LEFT && (mods & RACK_MOD_MASK) == (GLFW_MOD_CONTROL | GLFW_MOD_SHIFT)) {
- button = GLFW_MOUSE_BUTTON_MIDDLE;
- mods &= ~(GLFW_MOD_CONTROL | GLFW_MOD_SHIFT);
- }
#endif
- APP->event->handleButton(APP->window->internal->lastMousePos, button, action, mods);
-}
-
-static void cursorPosCallback(GLFWwindow* win, double xpos, double ypos) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
- math::Vec mousePos = math::Vec(xpos, ypos).div(APP->window->pixelRatio / APP->window->windowRatio).round();
- math::Vec mouseDelta = mousePos.minus(APP->window->internal->lastMousePos);
+Window::Window() {
+ internal = new Internal;
- // Workaround for GLFW warping mouse to a different position when the cursor is locked or unlocked.
- if (APP->window->internal->ignoreNextMouseDelta) {
- APP->window->internal->ignoreNextMouseDelta = false;
- mouseDelta = math::Vec();
- }
+ DGL_NAMESPACE::Window::ScopedGraphicsContext sgc(internal->hiddenWindow);
- int cursorMode = glfwGetInputMode(win, GLFW_CURSOR);
- (void) cursorMode;
+ // Set up NanoVG
+ const int nvgFlags = NVG_ANTIALIAS;
+ vg = nvgCreateGL(nvgFlags);
+ DISTRHO_SAFE_ASSERT_RETURN(vg != nullptr,);
+#ifdef NANOVG_GLES2
+ fbVg = nvgCreateSharedGLES2(vg, nvgFlags);
+#else
+ fbVg = nvgCreateSharedGL2(vg, nvgFlags);
+#endif
-#if defined ARCH_MAC
- // Workaround for Mac. We can't use GLFW_CURSOR_DISABLED because it's buggy, so implement it on our own.
- // This is not an ideal implementation. For example, if the user drags off the screen, the new mouse position will be clamped.
- if (cursorMode == GLFW_CURSOR_HIDDEN) {
- // CGSetLocalEventsSuppressionInterval(0.0);
- glfwSetCursorPos(win, APP->window->internal->lastMousePos.x, APP->window->internal->lastMousePos.y);
- CGAssociateMouseAndMouseCursorPosition(true);
- mousePos = APP->window->internal->lastMousePos;
- }
- // Because sometimes the cursor turns into an arrow when its position is on the boundary of the window
- glfwSetCursor(win, NULL);
+ // Load default Blendish font
+#ifndef DGL_NO_SHARED_RESOURCES
+ uiFont = std::make_shared<Font>();
+ uiFont->vg = vg;
+ uiFont->handle = loadFallbackFont(vg);
+
+ std::shared_ptr<FontWithOriginalContext> uiFont2;
+ uiFont2 = std::make_shared<FontWithOriginalContext>();
+ uiFont2->vg = vg;
+ uiFont2->handle = loadFallbackFont(vg);
+ uiFont2->ofilename = asset::system("res/fonts/DejaVuSans.ttf");
+ internal->fontCache[uiFont2->ofilename] = uiFont2;
+#else
+ uiFont = loadFont(asset::system("res/fonts/DejaVuSans.ttf"));
#endif
- APP->window->internal->lastMousePos = mousePos;
+ if (uiFont != nullptr)
+ bndSetFont(uiFont->handle);
+}
- APP->event->handleHover(mousePos, mouseDelta);
+void WindowSetPluginUI(Window* const window, DISTRHO_NAMESPACE::UI* const ui)
+{
+ if (ui != nullptr)
+ {
+ const GLubyte* vendor = glGetString(GL_VENDOR);
+ const GLubyte* renderer = glGetString(GL_RENDERER);
+ const GLubyte* version = glGetString(GL_VERSION);
+ INFO("Renderer: %s %s", vendor, renderer);
+ INFO("OpenGL: %s", version);
+
+ window->internal->ui = ui;
+ window->internal->size = rack::math::Vec(ui->getWidth(), ui->getHeight());
+
+ // Set up NanoVG
+ window->internal->r_vg = ui->getContext();
+#ifdef NANOVG_GLES2
+ window->internal->r_fbVg = nvgCreateSharedGLES2(window->internal->r_vg, NVG_ANTIALIAS);
+#else
+ window->internal->r_fbVg = nvgCreateSharedGL2(window->internal->r_vg, NVG_ANTIALIAS);
+#endif
- // Keyboard/mouse MIDI driver
- int width, height;
- glfwGetWindowSize(win, &width, &height);
- math::Vec scaledPos(xpos / width, ypos / height);
- keyboard::mouseMove(scaledPos);
-}
+ // swap contexts
+ window->internal->o_vg = window->vg;
+ window->internal->o_fbVg = window->fbVg;
+ window->vg = window->internal->r_vg;
+ window->fbVg = window->internal->r_fbVg;
+
+ // also for fonts and images
+ window->uiFont->vg = window->vg;
+ window->uiFont->handle = loadFallbackFont(window->vg);
+ for (auto& font : window->internal->fontCache)
+ {
+ font.second->vg = window->vg;
+ font.second->ohandle = font.second->handle;
+ font.second->handle = nvgCreateFont(window->vg,
+ font.second->ofilename.c_str(), font.second->ofilename.c_str());
+ }
+ for (auto& image : window->internal->imageCache)
+ {
+ image.second->vg = window->vg;
+ image.second->ohandle = image.second->handle;
+ image.second->handle = nvgCreateImage(window->vg, image.second->ofilename.c_str(),
+ NVG_IMAGE_REPEATX | NVG_IMAGE_REPEATY);
+ }
+ // Init settings
+ WindowParametersRestore(window);
-static void cursorEnterCallback(GLFWwindow* win, int entered) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
- if (!entered) {
- APP->event->handleLeave();
+ widget::Widget::ContextCreateEvent e;
+ APP->scene->onContextCreate(e);
}
-}
+ else
+ {
+ widget::Widget::ContextDestroyEvent e;
+ APP->scene->onContextDestroy(e);
+ // swap contexts
+ window->uiFont->vg = window->internal->o_vg;
+ window->vg = window->internal->o_vg;
+ window->fbVg = window->internal->o_fbVg;
+ window->internal->o_vg = nullptr;
+ window->internal->o_fbVg = nullptr;
+
+ // also for fonts and images
+ window->uiFont->vg = window->vg;
+ window->uiFont->handle = loadFallbackFont(window->vg);
+ for (auto& font : window->internal->fontCache)
+ {
+ font.second->vg = window->vg;
+ font.second->handle = font.second->ohandle;
+ font.second->ohandle = -1;
+ }
+ for (auto& image : window->internal->imageCache)
+ {
+ image.second->vg = window->vg;
+ image.second->handle = image.second->ohandle;
+ image.second->ohandle = -1;
+ }
-static void scrollCallback(GLFWwindow* win, double x, double y) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
- math::Vec scrollDelta = math::Vec(x, y);
-#if defined ARCH_MAC
- scrollDelta = scrollDelta.mult(10.0);
+#if defined NANOVG_GLES2
+ nvgDeleteGLES2(window->internal->r_fbVg);
#else
- scrollDelta = scrollDelta.mult(50.0);
+ nvgDeleteGL2(window->internal->r_fbVg);
#endif
- APP->event->handleScroll(APP->window->internal->lastMousePos, scrollDelta);
+ window->internal->ui = nullptr;
+ window->internal->callback = nullptr;
+ }
}
-
-static void charCallback(GLFWwindow* win, unsigned int codepoint) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
- if (APP->event->handleText(APP->window->internal->lastMousePos, codepoint))
- return;
+void WindowSetMods(Window* const window, const int mods)
+{
+ window->internal->mods = mods;
}
-
-static void keyCallback(GLFWwindow* win, int key, int scancode, int action, int mods) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
- if (APP->event->handleKey(APP->window->internal->lastMousePos, key, scancode, action, mods))
- return;
-
- // Keyboard/mouse MIDI driver
- if (action == GLFW_PRESS && (mods & RACK_MOD_MASK) == 0) {
- keyboard::press(key);
- }
- if (action == GLFW_RELEASE) {
- keyboard::release(key);
+Window::~Window() {
+ {
+ DGL_NAMESPACE::Window::ScopedGraphicsContext sgc(internal->hiddenWindow);
+ internal->hiddenWindow.close();
+ internal->hiddenApp.idle();
+
+ // Fonts and Images in the cache must be deleted before the NanoVG context is deleted
+ internal->fontCache.clear();
+ internal->imageCache.clear();
+
+#if defined NANOVG_GLES2
+ nvgDeleteGLES2(internal->o_fbVg != nullptr ? internal->o_fbVg : fbVg);
+ nvgDeleteGLES2(internal->o_vg != nullptr ? internal->o_vg : vg);
+#else
+ nvgDeleteGL2(internal->o_fbVg != nullptr ? internal->o_fbVg : fbVg);
+ nvgDeleteGL2(internal->o_vg != nullptr ? internal->o_vg : vg);
+#endif
}
-}
-
-static void dropCallback(GLFWwindow* win, int count, const char** paths) {
- contextSet((Context*) glfwGetWindowUserPointer(win));
- std::vector<std::string> pathsVec;
- for (int i = 0; i < count; i++) {
- pathsVec.push_back(paths[i]);
- }
- APP->event->handleDrop(APP->window->internal->lastMousePos, pathsVec);
+ delete internal;
}
-static void errorCallback(int error, const char* description) {
- WARN("GLFW error %d: %s", error, description);
+math::Vec Window::getSize() {
+ return internal->size;
}
-Window::Window() {
- internal = new Internal;
- int err;
-
- // Set window hints
-#if defined NANOVG_GL2
- glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
- glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
-#elif defined NANOVG_GL3
- glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
- glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 2);
- glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
- glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
-#endif
- glfwWindowHint(GLFW_DOUBLEBUFFER, GLFW_TRUE);
- glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE);
-
-#if defined ARCH_MAC
- glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
-#endif
-
- // Create window
- win = glfwCreateWindow(1024, 720, "", NULL, NULL);
- if (!win) {
- 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.");
- throw Exception("Could not create Window");
- }
-
- float contentScale;
- glfwGetWindowContentScale(win, &contentScale, NULL);
- INFO("Window content scale: %f", contentScale);
-
- glfwSetWindowSizeLimits(win, WINDOW_SIZE_MIN.x, WINDOW_SIZE_MIN.y, GLFW_DONT_CARE, GLFW_DONT_CARE);
- if (settings::windowSize.x > 0 && settings::windowSize.y > 0) {
- glfwSetWindowSize(win, settings::windowSize.x, settings::windowSize.y);
- }
- if (settings::windowPos.x > -32000 && settings::windowPos.y > -32000) {
- glfwSetWindowPos(win, settings::windowPos.x, settings::windowPos.y);
- }
- if (settings::windowMaximized) {
- glfwMaximizeWindow(win);
- }
- glfwShowWindow(win);
-
- glfwSetWindowUserPointer(win, contextGet());
- glfwSetInputMode(win, GLFW_LOCK_KEY_MODS, 1);
-
- glfwMakeContextCurrent(win);
- glfwSwapInterval(1);
- const GLFWvidmode* monitorMode = glfwGetVideoMode(glfwGetPrimaryMonitor());
- if (monitorMode->refreshRate > 0) {
- internal->monitorRefreshRate = monitorMode->refreshRate;
- }
- else {
- // Some monitors report 0Hz refresh rate for some reason, so as a workaround, assume 60Hz.
- internal->monitorRefreshRate = 60;
- }
-
- // Set window callbacks
- glfwSetWindowPosCallback(win, windowPosCallback);
- glfwSetWindowSizeCallback(win, windowSizeCallback);
- glfwSetWindowMaximizeCallback(win, windowMaximizeCallback);
- glfwSetMouseButtonCallback(win, mouseButtonCallback);
- // Call this ourselves, but on every frame instead of only when the mouse moves
- // glfwSetCursorPosCallback(win, cursorPosCallback);
- glfwSetCursorEnterCallback(win, cursorEnterCallback);
- glfwSetScrollCallback(win, scrollCallback);
- glfwSetCharCallback(win, charCallback);
- glfwSetKeyCallback(win, keyCallback);
- glfwSetDropCallback(win, dropCallback);
-
- // Set up GLEW
- glewExperimental = GL_TRUE;
- err = glewInit();
- if (err != GLEW_OK) {
- 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.");
- throw Exception("Could not initialize GLEW");
- }
-
- const GLubyte* vendor = glGetString(GL_VENDOR);
- const GLubyte* renderer = glGetString(GL_RENDERER);
- const GLubyte* version = glGetString(GL_VERSION);
- INFO("Renderer: %s %s", vendor, renderer);
- INFO("OpenGL: %s", version);
-
- // GLEW generates GL error because it calls glGetString(GL_EXTENSIONS), we'll consume it here.
- glGetError();
+void Window::setSize(math::Vec size) {
+ size = size.max(WINDOW_SIZE_MIN);
+ internal->size = size;
- // Set up NanoVG
- int nvgFlags = NVG_ANTIALIAS;
-#if defined NANOVG_GL2
- vg = nvgCreateGL2(nvgFlags);
- fbVg = nvgCreateSharedGL2(vg, nvgFlags);
-#elif defined NANOVG_GL3
- vg = nvgCreateGL3(nvgFlags);
-#elif defined NANOVG_GLES2
- vg = nvgCreateGLES2(nvgFlags);
-#endif
- if (!vg) {
- 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.");
- throw Exception("Could not initialize NanoVG");
- }
+ if (DISTRHO_NAMESPACE::UI* const ui = internal->ui)
+ ui->setSize(internal->size.x, internal->size.y);
+}
- // Load default Blendish font
- uiFont = loadFont(asset::system("res/fonts/DejaVuSans.ttf"));
- bndSetFont(uiFont->handle);
- if (APP->scene) {
- widget::Widget::ContextCreateEvent e;
- APP->scene->onContextCreate(e);
- }
+void Window::run() {
+ internal->frame = 0;
}
-Window::~Window() {
- if (APP->scene) {
- widget::Widget::ContextDestroyEvent e;
- APP->scene->onContextDestroy(e);
+static void Window__flipBitmap(uint8_t* pixels, const int width, const int height, const int depth) {
+ for (int y = 0; y < height / 2; y++) {
+ const int flipY = height - y - 1;
+ uint8_t tmp[width * depth];
+ std::memcpy(tmp, &pixels[y * width * depth], width * depth);
+ std::memmove(&pixels[y * width * depth], &pixels[flipY * width * depth], width * depth);
+ std::memcpy(&pixels[flipY * width * depth], tmp, width * depth);
}
-
- // Fonts and Images in the cache must be deleted before the NanoVG context is deleted
- internal->fontCache.clear();
- internal->imageCache.clear();
-
- // nvgDeleteClone(fbVg);
-
-#if defined NANOVG_GL2
- nvgDeleteGL2(vg);
- nvgDeleteGL2(fbVg);
-#elif defined NANOVG_GL3
- nvgDeleteGL3(vg);
-#elif defined NANOVG_GLES2
- nvgDeleteGLES2(vg);
-#endif
-
- glfwDestroyWindow(win);
- delete internal;
}
-math::Vec Window::getSize() {
- int width, height;
- glfwGetWindowSize(win, &width, &height);
- return math::Vec(width, height);
-}
-
+#ifdef STBI_WRITE_NO_STDIO
+static void Window__downscaleBitmap(uint8_t* pixels, int& width, int& height) {
+ int targetWidth = width;
+ int targetHeight = height;
+ double scale = 1.0;
+
+ if (targetWidth > 340) {
+ scale = width / 340.0;
+ targetWidth = 340;
+ targetHeight = height / scale;
+ }
+ if (targetHeight > 210) {
+ scale = height / 210.0;
+ targetHeight = 210;
+ targetWidth = width / scale;
+ }
+ DISTRHO_SAFE_ASSERT_INT_RETURN(targetWidth <= 340, targetWidth,);
+ DISTRHO_SAFE_ASSERT_INT_RETURN(targetHeight <= 210, targetHeight,);
+
+ // FIXME worst possible quality :/
+ for (int y = 0; y < targetHeight; ++y) {
+ const int ys = static_cast<int>(y * scale);
+ for (int x = 0; x < targetWidth; ++x) {
+ const int xs = static_cast<int>(x * scale);
+ std::memmove(pixels + (width * y + x) * 3, pixels + (width * ys + xs) * 3, 3);
+ }
+ }
-void Window::setSize(math::Vec size) {
- size = size.max(WINDOW_SIZE_MIN);
- glfwSetWindowSize(win, size.x, size.y);
+ width = targetWidth;
+ height = targetHeight;
}
-
-void Window::run() {
- internal->frame = 0;
- while (!glfwWindowShouldClose(win)) {
- step();
- }
+static void Window__writeImagePNG(void* context, void* data, int size) {
+ USE_NAMESPACE_DISTRHO
+ UI* const ui = static_cast<UI*>(context);
+ ui->setState("screenshot", String::asBase64(data, size).buffer());
}
+#endif
void Window::step() {
+ DISTRHO_SAFE_ASSERT_RETURN(internal->ui != nullptr,);
+
double frameTime = system::getTime();
double lastFrameTime = internal->frameTime;
internal->frameTime = frameTime;
internal->lastFrameDuration = frameTime - lastFrameTime;
internal->fbCount = 0;
// DEBUG("%.2lf Hz", 1.0 / internal->lastFrameDuration);
- // double t1 = 0.0, t2 = 0.0, t3 = 0.0, t4 = 0.0, t5 = 0.0;
// Make event handlers and step() have a clean NanoVG context
nvgReset(vg);
- bndSetFont(uiFont->handle);
-
- // Poll events
- // Save and restore context because event handler set their own context based on which window they originate from.
- Context* context = contextGet();
- glfwPollEvents();
- contextSet(context);
-
- // In case glfwPollEvents() sets another OpenGL context
- glfwMakeContextCurrent(win);
- if (settings::frameSwapInterval != internal->frameSwapInterval) {
- glfwSwapInterval(settings::frameSwapInterval);
- internal->frameSwapInterval = settings::frameSwapInterval;
- }
-
- // Call cursorPosCallback every frame, not just when the mouse moves
- {
- double xpos, ypos;
- glfwGetCursorPos(win, &xpos, &ypos);
- cursorPosCallback(win, xpos, ypos);
- }
- gamepad::step();
+ if (uiFont != nullptr)
+ bndSetFont(uiFont->handle);
// Set window title
- std::string windowTitle = APP_NAME + " " + APP_EDITION_NAME + " " + APP_VERSION;
+ std::string windowTitle = "Cardinal";
if (APP->patch->path != "") {
windowTitle += " - ";
if (!APP->history->isSaved())
@@ -455,243 +437,155 @@
windowTitle += system::getFilename(APP->patch->path);
}
if (windowTitle != internal->lastWindowTitle) {
- glfwSetWindowTitle(win, windowTitle.c_str());
+ internal->ui->getWindow().setTitle(windowTitle.c_str());
internal->lastWindowTitle = windowTitle;
}
// Get desired pixel ratio
- float newPixelRatio;
- if (settings::pixelRatio > 0.0) {
- newPixelRatio = settings::pixelRatio;
- }
- else {
- glfwGetWindowContentScale(win, &newPixelRatio, NULL);
- newPixelRatio = std::floor(newPixelRatio + 0.5);
- }
+ float newPixelRatio = internal->ui->getScaleFactor();
if (newPixelRatio != pixelRatio) {
pixelRatio = newPixelRatio;
APP->event->handleDirty();
}
+ // Hide menu and background if generating screenshot
+ if (internal->generateScreenshotStep == kScreenshotStepStarted) {
+#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS
+ APP->scene->menuBar->hide();
+ APP->scene->rack->children.front()->hide();
+#else
+ internal->generateScreenshotStep = kScreenshotStepSecondPass;
+#endif
+ }
+
// Get framebuffer/window ratio
- int fbWidth, fbHeight;
- glfwGetFramebufferSize(win, &fbWidth, &fbHeight);
- int winWidth, winHeight;
- glfwGetWindowSize(win, &winWidth, &winHeight);
+ int winWidth = internal->ui->getWidth();
+ int winHeight = internal->ui->getHeight();
+ int fbWidth = winWidth;// * newPixelRatio;
+ int fbHeight = winHeight;// * newPixelRatio;
windowRatio = (float)fbWidth / winWidth;
- // t1 = system::getTime();
if (APP->scene) {
// DEBUG("%f %f %d %d", pixelRatio, windowRatio, fbWidth, winWidth);
// Resize scene
- APP->scene->box.size = math::Vec(fbWidth, fbHeight).div(pixelRatio);
+ APP->scene->box.size = math::Vec(fbWidth, fbHeight).div(newPixelRatio);
// Step scene
APP->scene->step();
- // t2 = system::getTime();
// Render scene
- bool visible = glfwGetWindowAttrib(win, GLFW_VISIBLE) && !glfwGetWindowAttrib(win, GLFW_ICONIFIED);
- if (visible) {
+ {
// Update and render
- nvgBeginFrame(vg, fbWidth, fbHeight, pixelRatio);
- nvgScale(vg, pixelRatio, pixelRatio);
+ nvgScale(vg, newPixelRatio, newPixelRatio);
// Draw scene
widget::Widget::DrawArgs args;
args.vg = vg;
args.clipBox = APP->scene->box.zeroPos();
APP->scene->draw(args);
- // t3 = system::getTime();
glViewport(0, 0, fbWidth, fbHeight);
+#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS
+ glClearColor(0.0, 0.0, 0.0, 0.0);
+#else
glClearColor(0.0, 0.0, 0.0, 1.0);
+#endif
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
- nvgEndFrame(vg);
- // t4 = system::getTime();
}
}
- glfwSwapBuffers(win);
+ ++internal->frame;
- // On some platforms, glfwSwapBuffers() doesn't wait on monitor refresh, so we have to sleep as a fallback.
- double frameDurationRemaining = getFrameDurationRemaining();
- if (frameDurationRemaining > 0.0) {
- std::this_thread::sleep_for(std::chrono::duration<double>(frameDurationRemaining));
- }
-
- // t5 = system::getTime();
-
- // DEBUG("pre-step %6.1f step %6.1f draw %6.1f nvgEndFrame %6.1f glfwSwapBuffers %6.1f total %6.1f",
- // (t1 - frameTime) * 1e3f,
- // (t2 - t1) * 1e3f,
- // (t3 - t2) * 1e3f,
- // (t4 - t2) * 1e3f,
- // (t5 - t4) * 1e3f,
- // (t5 - frameTime) * 1e3f
- // );
- internal->frame++;
-}
+ if (internal->generateScreenshotStep != kScreenshotStepNone) {
+ ++internal->generateScreenshotStep;
+ int y = 0;
+#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS
+ constexpr const int depth = 4;
+#else
+ y = APP->scene->menuBar->box.size.y * newPixelRatio;
+ constexpr const int depth = 3;
+#endif
-void Window::activateContext() {
- glfwMakeContextCurrent(win);
-}
+ // Allocate pixel color buffer
+ uint8_t* const pixels = new uint8_t[winHeight * winWidth * 4];
+ // glReadPixels defaults to GL_BACK, but the back-buffer is unstable, so use the front buffer (what the user sees)
+ glReadBuffer(GL_FRONT);
+ glReadPixels(0, 0, winWidth, winHeight, depth == 3 ? GL_RGB : GL_RGBA, GL_UNSIGNED_BYTE, pixels);
-static void flipBitmap(uint8_t* pixels, int width, int height, int depth) {
- for (int y = 0; y < height / 2; y++) {
- int flipY = height - y - 1;
- uint8_t tmp[width * depth];
- std::memcpy(tmp, &pixels[y * width * depth], width * depth);
- std::memcpy(&pixels[y * width * depth], &pixels[flipY * width * depth], width * depth);
- std::memcpy(&pixels[flipY * width * depth], tmp, width * depth);
+ if (internal->generateScreenshotStep == kScreenshotStepSaving)
+ {
+ // Write pixels to PNG
+ const int stride = winWidth * depth;
+ uint8_t* const pixelsWithOffset = pixels + (stride * y);
+ Window__flipBitmap(pixels, winWidth, winHeight, depth);
+ winHeight -= y;
+#ifdef STBI_WRITE_NO_STDIO
+ Window__downscaleBitmap(pixelsWithOffset, winWidth, winHeight);
+ stbi_write_png_to_func(Window__writeImagePNG, internal->ui,
+ winWidth, winHeight, depth, pixelsWithOffset, stride);
+#else
+ stbi_write_png("screenshot.png", winWidth, winHeight, depth, pixelsWithOffset, stride);
+#endif
+
+ internal->generateScreenshotStep = kScreenshotStepNone;
+ APP->scene->menuBar->show();
+ APP->scene->rack->children.front()->show();
+ }
+
+ delete[] pixels;
}
}
-void Window::screenshot(const std::string& screenshotPath) {
- // Get window framebuffer size
- int width, height;
- glfwGetFramebufferSize(APP->window->win, &width, &height);
-
- // Allocate pixel color buffer
- uint8_t* pixels = new uint8_t[height * width * 4];
-
- // glReadPixels defaults to GL_BACK, but the back-buffer is unstable, so use the front buffer (what the user sees)
- glReadBuffer(GL_FRONT);
- glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
-
- // Write pixels to PNG
- flipBitmap(pixels, width, height, 4);
- stbi_write_png(screenshotPath.c_str(), width, height, 4, pixels, width * 4);
-
- delete[] pixels;
-}
-
-
-void Window::screenshotModules(const std::string& screenshotsDir, float zoom) {
- // Iterate plugins and create directories
- system::createDirectories(screenshotsDir);
- for (plugin::Plugin* p : plugin::plugins) {
- std::string dir = system::join(screenshotsDir, p->slug);
- system::createDirectory(dir);
- for (plugin::Model* model : p->models) {
- std::string filename = system::join(dir, model->slug + ".png");
-
- // Skip model if screenshot already exists
- if (system::isFile(filename))
- continue;
-
- INFO("Screenshotting %s %s to %s", p->slug.c_str(), model->slug.c_str(), filename.c_str());
-
- // Create widgets
- widget::FramebufferWidget* fbw = new widget::FramebufferWidget;
- fbw->oversample = 2;
-
- struct ModuleWidgetContainer : widget::Widget {
- void draw(const DrawArgs& args) override {
- Widget::draw(args);
- Widget::drawLayer(args, 1);
- }
- };
- ModuleWidgetContainer* mwc = new ModuleWidgetContainer;
- fbw->addChild(mwc);
-
- app::ModuleWidget* mw = model->createModuleWidget(NULL);
- mwc->box.size = mw->box.size;
- fbw->box.size = mw->box.size;
- mwc->addChild(mw);
-
- // Step to allow the ModuleWidget state to set its default appearance.
- fbw->step();
-
- // Draw to framebuffer
- fbw->render(math::Vec(zoom, zoom));
-
- // Read pixels
- nvgluBindFramebuffer(fbw->getFramebuffer());
- int width, height;
- nvgImageSize(vg, fbw->getImageHandle(), &width, &height);
- uint8_t* pixels = new uint8_t[height * width * 4];
- glReadPixels(0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
+void Window::activateContext() {
+}
- // Write pixels to PNG
- flipBitmap(pixels, width, height, 4);
- stbi_write_png(filename.c_str(), width, height, 4, pixels, width * 4);
- // Cleanup
- delete[] pixels;
- nvgluBindFramebuffer(NULL);
- delete fbw;
- }
- }
+void Window::screenshot(const std::string&) {
+}
+
+
+void Window::screenshotModules(const std::string&, float) {
}
void Window::close() {
- glfwSetWindowShouldClose(win, GLFW_TRUE);
+ DISTRHO_SAFE_ASSERT_RETURN(internal->ui != nullptr,);
+
+ internal->ui->getWindow().close();
}
void Window::cursorLock() {
- if (!settings::allowCursorLock)
- return;
-
-#if defined ARCH_MAC
- glfwSetInputMode(win, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
-#else
- glfwSetInputMode(win, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
-#endif
- internal->ignoreNextMouseDelta = true;
}
void Window::cursorUnlock() {
- if (!settings::allowCursorLock)
- return;
-
- glfwSetInputMode(win, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
- internal->ignoreNextMouseDelta = true;
}
bool Window::isCursorLocked() {
- return glfwGetInputMode(win, GLFW_CURSOR) != GLFW_CURSOR_NORMAL;
+ return false;
}
int Window::getMods() {
- int mods = 0;
- if (glfwGetKey(win, GLFW_KEY_LEFT_SHIFT) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_SHIFT) == GLFW_PRESS)
- mods |= GLFW_MOD_SHIFT;
- if (glfwGetKey(win, GLFW_KEY_LEFT_CONTROL) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_CONTROL) == GLFW_PRESS)
- mods |= GLFW_MOD_CONTROL;
- if (glfwGetKey(win, GLFW_KEY_LEFT_ALT) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_ALT) == GLFW_PRESS)
- mods |= GLFW_MOD_ALT;
- if (glfwGetKey(win, GLFW_KEY_LEFT_SUPER) == GLFW_PRESS || glfwGetKey(win, GLFW_KEY_RIGHT_SUPER) == GLFW_PRESS)
- mods |= GLFW_MOD_SUPER;
- return mods;
+ return internal->mods;
}
-void Window::setFullScreen(bool fullScreen) {
- if (!fullScreen) {
- glfwSetWindowMonitor(win, NULL, internal->lastWindowX, internal->lastWindowY, internal->lastWindowWidth, internal->lastWindowHeight, GLFW_DONT_CARE);
- }
- else {
- glfwGetWindowPos(win, &internal->lastWindowX, &internal->lastWindowY);
- glfwGetWindowSize(win, &internal->lastWindowWidth, &internal->lastWindowHeight);
- GLFWmonitor* monitor = glfwGetPrimaryMonitor();
- const GLFWvidmode* mode = glfwGetVideoMode(monitor);
- glfwSetWindowMonitor(win, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
- }
+void Window::setFullScreen(bool) {
}
bool Window::isFullScreen() {
- GLFWmonitor* monitor = glfwGetWindowMonitor(win);
- return monitor != NULL;
+#ifdef CARDINAL_TRANSPARENT_SCREENSHOTS
+ return internal->generateScreenshotStep != kScreenshotStepNone;
+#else
+ return false;
+#endif
}
@@ -722,14 +616,15 @@
return pair->second;
// Load font
- std::shared_ptr<Font> font;
+ std::shared_ptr<FontWithOriginalContext> font;
try {
- font = std::make_shared<Font>();
+ font = std::make_shared<FontWithOriginalContext>();
+ font->ofilename = filename;
font->loadFile(filename, vg);
}
catch (Exception& e) {
WARN("%s", e.what());
- font = NULL;
+ font = nullptr;
}
internal->fontCache[filename] = font;
return font;
@@ -742,14 +637,15 @@
return pair->second;
// Load image
- std::shared_ptr<Image> image;
+ std::shared_ptr<ImageWithOriginalContext> image;
try {
- image = std::make_shared<Image>();
+ image = std::make_shared<ImageWithOriginalContext>();
+ image->ofilename = filename;
image->loadFile(filename, vg);
}
catch (Exception& e) {
WARN("%s", e.what());
- image = NULL;
+ image = nullptr;
}
internal->imageCache[filename] = image;
return image;
@@ -766,28 +662,146 @@
}
-void init() {
- int err;
+void generateScreenshot() {
+ APP->window->internal->generateScreenshotStep = kScreenshotStepStarted;
+}
- // Set up GLFW
-#if defined ARCH_MAC
- glfwInitHint(GLFW_COCOA_CHDIR_RESOURCES, GLFW_TRUE);
- glfwInitHint(GLFW_COCOA_MENUBAR, GLFW_FALSE);
-#endif
- glfwSetErrorCallback(errorCallback);
- err = glfwInit();
- if (err != GLFW_TRUE) {
- osdialog_message(OSDIALOG_ERROR, OSDIALOG_OK, "Could not initialize GLFW.");
- throw Exception("Could not initialize GLFW");
- }
+void init() {
}
void destroy() {
- glfwTerminate();
}
} // namespace window
} // namespace rack
+
+
+START_NAMESPACE_DISTRHO
+
+void WindowParametersSave(rack::window::Window* const window)
+{
+ if (d_isNotEqual(window->internal->params.cableOpacity, rack::settings::cableOpacity))
+ {
+ window->internal->params.cableOpacity = rack::settings::cableOpacity;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterCableOpacity,
+ rack::settings::cableOpacity);
+ }
+ if (d_isNotEqual(window->internal->params.cableTension, rack::settings::cableTension))
+ {
+ window->internal->params.cableTension = rack::settings::cableTension;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterCableTension,
+ rack::settings::cableTension);
+ }
+ if (d_isNotEqual(window->internal->params.rackBrightness, rack::settings::rackBrightness))
+ {
+ window->internal->params.rackBrightness = rack::settings::rackBrightness;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterRackBrightness,
+ rack::settings::rackBrightness);
+ }
+ if (d_isNotEqual(window->internal->params.haloBrightness, rack::settings::haloBrightness))
+ {
+ window->internal->params.haloBrightness = rack::settings::haloBrightness;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterHaloBrightness,
+ rack::settings::haloBrightness);
+ }
+ if (d_isNotEqual(window->internal->params.knobScrollSensitivity, rack::settings::knobScrollSensitivity))
+ {
+ window->internal->params.knobScrollSensitivity = rack::settings::knobScrollSensitivity;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterWheelSensitivity,
+ rack::settings::knobScrollSensitivity);
+ }
+ if (d_isNotEqual(window->internal->params.browserZoom, rack::settings::browserZoom))
+ {
+ window->internal->params.browserZoom = rack::settings::browserZoom;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterBrowserZoom,
+ rack::settings::browserZoom);
+ }
+ if (window->internal->params.knobMode != rack::settings::knobMode)
+ {
+ window->internal->params.knobMode = rack::settings::knobMode;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterKnobMode,
+ rack::settings::knobMode);
+ }
+ if (window->internal->params.browserSort != rack::settings::browserSort)
+ {
+ window->internal->params.browserSort = rack::settings::browserSort;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterBrowserSort,
+ rack::settings::browserSort);
+ }
+ if (window->internal->params.tooltips != rack::settings::tooltips)
+ {
+ window->internal->params.tooltips = rack::settings::tooltips;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterShowTooltips,
+ rack::settings::tooltips);
+ }
+ if (window->internal->params.knobScroll != rack::settings::knobScroll)
+ {
+ window->internal->params.knobScroll = rack::settings::knobScroll;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterWheelKnobControl,
+ rack::settings::knobScroll);
+ }
+ if (window->internal->params.lockModules != rack::settings::lockModules)
+ {
+ window->internal->params.lockModules = rack::settings::lockModules;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterLockModulePositions,
+ rack::settings::lockModules);
+ }
+ if (window->internal->params.invertZoom != rack::settings::invertZoom)
+ {
+ window->internal->params.invertZoom = rack::settings::invertZoom;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterInvertZoom,
+ rack::settings::invertZoom);
+ }
+ if (window->internal->params.rateLimit != rack::settings::rateLimit)
+ {
+ window->internal->params.rateLimit = rack::settings::rateLimit;
+ if (window->internal->callback != nullptr)
+ window->internal->callback->WindowParametersChanged(kWindowParameterUpdateRateLimit,
+ rack::settings::rateLimit);
+ }
+}
+
+void WindowParametersRestore(rack::window::Window* const window)
+{
+ rack::settings::cableOpacity = window->internal->params.cableOpacity;
+ rack::settings::cableTension = window->internal->params.cableTension;
+ rack::settings::rackBrightness = window->internal->params.rackBrightness;
+ rack::settings::haloBrightness = window->internal->params.haloBrightness;
+ rack::settings::knobScrollSensitivity = window->internal->params.knobScrollSensitivity;
+ rack::settings::browserZoom = window->internal->params.browserZoom;
+ rack::settings::knobMode = static_cast<rack::settings::KnobMode>(window->internal->params.knobMode);
+ rack::settings::browserSort = static_cast<rack::settings::BrowserSort>(window->internal->params.browserSort);
+ rack::settings::tooltips = window->internal->params.tooltips;
+ rack::settings::knobScroll = window->internal->params.knobScroll;
+ rack::settings::lockModules = window->internal->params.lockModules;
+ rack::settings::invertZoom = window->internal->params.invertZoom;
+ rack::settings::rateLimit = window->internal->params.rateLimit;
+}
+
+void WindowParametersSetCallback(rack::window::Window* const window, WindowParametersCallback* const callback)
+{
+ window->internal->callback = callback;
+}
+
+void WindowParametersSetValues(rack::window::Window* const window, const WindowParameters& params)
+{
+ window->internal->params = params;
+}
+
+END_NAMESPACE_DISTRHO
+
Reference in a new issue View git blame Copy permalink