From ffd3f44464033d7bd078c57d6598faf74bd9ca08 Mon Sep 17 00:00:00 2001 From: Mars Date: Mon, 30 Sep 2024 16:46:17 -0400 Subject: [PATCH] vkfw --- src/main.cpp | 49 +- src/util/vkfw.hpp | 5015 +++++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 5030 insertions(+), 34 deletions(-) create mode 100644 src/util/vkfw.hpp diff --git a/src/main.cpp b/src/main.cpp index 9dc1879..f322923 100644 --- a/src/main.cpp +++ b/src/main.cpp @@ -10,8 +10,8 @@ #define VULKAN_HPP_NO_CONSTRUCTORS #include -#include "util/magic_enum.hpp" #include "util/types.h" +#include "util/vkfw.hpp" namespace vk { using DebugUtilsMessengerUnique = vk::UniqueHandle; @@ -34,11 +34,11 @@ class VulkanApp { initWindow(); initVulkan(); mainLoop(); - cleanup(); } private: - GLFWwindow* mWindow; + vkfw::UniqueInstance mGLFWInstance; + vkfw::UniqueWindow mWindow; vk::UniqueInstance mInstance; @@ -61,12 +61,16 @@ class VulkanApp { }; fn initWindow() -> void { - glfwInit(); + using namespace vkfw; - glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API); - glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); + mGLFWInstance = initUnique(); - mWindow = glfwCreateWindow(WIDTH, HEIGHT, "Vulkan", nullptr, nullptr); + WindowHints hints; + + hints.clientAPI = ClientAPI::eNone; + hints.resizable = false; + + mWindow = createWindowUnique(WIDTH, HEIGHT, "Vulkan", hints); } fn initVulkan() -> void { @@ -78,12 +82,7 @@ class VulkanApp { } fn mainLoop() -> void { - while (!glfwWindowShouldClose(mWindow)) { glfwPollEvents(); } - } - - fn cleanup() -> void { - glfwDestroyWindow(mWindow); - glfwTerminate(); + while (!mWindow->shouldClose()) { vkfw::waitEvents(); } } fn createInstance() -> void { @@ -143,18 +142,7 @@ class VulkanApp { mDebugMessenger = mInstance->createDebugUtilsMessengerEXTUnique(messengerCreateInfo, nullptr, mLoader); } - fn createSurface() -> void { - VkSurfaceKHR surface = nullptr; - - VkResult result = glfwCreateWindowSurface(mInstance.get(), mWindow, nullptr, &surface); - - if (result != VK_SUCCESS) - throw std::runtime_error( - "Failed to create window surface! Error code: " + string(magic_enum::enum_name(result)) - ); - - mSurface = vk::UniqueSurfaceKHR(surface, mInstance.get()); - } + fn createSurface() -> void { mSurface = vkfw::createWindowSurfaceUnique(mInstance.get(), mWindow.get()); } fn pickPhysicalDevice() -> void { std::vector devices = mInstance->enumeratePhysicalDevices(); @@ -243,16 +231,9 @@ class VulkanApp { } static fn getRequiredExtensions() -> std::vector { - u32 glfwExtensionCount = 0; - const char** glfwExtensions = nullptr; - glfwExtensions = glfwGetRequiredInstanceExtensions(&glfwExtensionCount); + std::span extensionsSpan = vkfw::getRequiredInstanceExtensions(); - std::vector extensions; - - if (glfwExtensions) { - std::span extSpan(glfwExtensions, glfwExtensionCount); - extensions.assign(extSpan.begin(), extSpan.end()); - } + std::vector extensions(extensionsSpan.begin(), extensionsSpan.end()); if (enableValidationLayers) extensions.push_back("VK_EXT_debug_utils"); diff --git a/src/util/vkfw.hpp b/src/util/vkfw.hpp new file mode 100644 index 0000000..1d97ab8 --- /dev/null +++ b/src/util/vkfw.hpp @@ -0,0 +1,5015 @@ +#pragma once +// Copyright (c) 2020 Cvelth. +// +// SPDX-License-Identifier: Apache-2.0 +// + +#ifdef _MSVC_LANG +#define VKFW_CPLUSPLUS _MSVC_LANG +#else +#define VKFW_CPLUSPLUS __cplusplus +#endif + +#if 201703L < VKFW_CPLUSPLUS +#define VKFW_CPP_VERSION 20 +#elif 201402L < VKFW_CPLUSPLUS +#define VKFW_CPP_VERSION 17 +#elif 201103L < VKFW_CPLUSPLUS +#define VKFW_CPP_VERSION 14 +#elif 199711L < VKFW_CPLUSPLUS +#define VKFW_CPP_VERSION 11 +#else +#error "vkfw.hpp needs at least c++ standard version 11" +#endif + +#if 20 <= VKFW_CPP_VERSION && defined(__has_include) && __has_include( ) +#include +#endif +#if !defined(VKFW_NO_STRING_VIEW) && 17 <= VKFW_CPP_VERSION +#include +#define VKFW_HAS_STRING_VIEW +#endif +#if !defined(VKFW_NO_SPAN) && 20 <= VKFW_CPP_VERSION && defined(__cpp_lib_span) && defined(__has_include) && \ + 202002L <= __cpp_lib_span && __has_include( ) +#include +#define VKFW_HAS_SPAN +#endif +#if !defined(VKFW_NO_SPACESHIP_OPERATOR) && 20 <= VKFW_CPP_VERSION && \ + defined(__cpp_impl_three_way_comparison) && defined(__has_include) && \ + 201711 <= __cpp_impl_three_way_comparison && __has_include( ) +#define VKFW_HAS_SPACESHIP_OPERATOR +#include +#endif + +#include +#include +#include +#include +#include + +#ifndef VKFW_INCLUDE_GL +#define GLFW_INCLUDE_NONE +#endif +#ifndef VKFW_NO_INCLUDE_VULKAN +#define GLFW_INCLUDE_VULKAN +#endif +#include + +#ifndef VKFW_NO_INCLUDE_VULKAN_HPP +#if defined(VKFW_NO_STRUCT_CONSTRUCTORS) && !defined(VULKAN_HPP_NO_STRUCT_CONSTRUCTORS) +#define VULKAN_HPP_NO_STRUCT_CONSTRUCTORS VKFW_NO_STRUCT_CONSTRUCTORS +#endif +#if defined(VKFW_NO_EXCEPTIONS) && !defined(VULKAN_HPP_NO_EXCEPTIONS) +#define VULKAN_HPP_NO_EXCEPTIONS VKFW_NO_EXCEPTIONS +#endif +#if defined(VKFW_NO_NODISCARD_WARNINGS) && !defined(VULKAN_HPP_NO_NODISCARD_WARNINGS) +#define VULKAN_HPP_NO_NODISCARD_WARNINGS VKFW_NO_NODISCARD_WARNINGS +#endif +#if defined(VKFW_ASSERT) && !defined(VULKAN_HPP_ASSERT) +#define VULKAN_HPP_ASSERT VKFW_ASSERT +#endif +#if defined(VKFW_ASSERT_ON_RESULT) && !defined(VULKAN_HPP_ASSERT_ON_RESULT) +#define VULKAN_HPP_ASSERT_ON_RESULT VKFW_ASSERT_ON_RESULT +#endif +#if defined(VKFW_DISABLE_ENHANCED_MODE) && !defined(VULKAN_HPP_DISABLE_ENHANCED_MODE) +#define VULKAN_HPP_DISABLE_ENHANCED_MODE VKFW_DISABLE_ENHANCED_MODE +#endif +#if defined(VKFW_HPP_INLINE) && !defined(VULKAN_HPP_INLINE) +#define VULKAN_HPP_INLINE VKFW_HPP_INLINE +#endif +#if defined(VKFW_NO_SMART_HANDLE) && !defined(VULKAN_HPP_NO_SMART_HANDLE) +#define VULKAN_HPP_NO_SMART_HANDLE VKFW_NO_SMART_HANDLE +#endif +#include +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE +#ifndef VKFW_NO_SMART_HANDLE +#define VKFW_NO_SMART_HANDLE +#endif +#else +#include +#include +#include +#include +#endif + +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS +#include +#endif + +#ifndef VKFW_ASSERT +#include +#define VKFW_ASSERT assert +#endif + +#ifndef VKFW_ASSERT_ON_RESULT +#define VKFW_ASSERT_ON_RESULT VKFW_ASSERT +#endif + +#define VKFW_VERSION_MAJOR 0 +#define VKFW_VERSION_MINOR 2 +#define VKFW_VERSION_PATCH 0 +#define VKFW_TARGET_GLFW_VERSION_MAJOR 3 +#define VKFW_TARGET_GLFW_VERSION_MINOR 4 + +static_assert( + GLFW_VERSION_MAJOR == VKFW_TARGET_GLFW_VERSION_MAJOR && + GLFW_VERSION_MINOR == VKFW_TARGET_GLFW_VERSION_MINOR, + "\"glfw3.h\" version is not compatible with the \"vkfw.hpp\" version!" +); + +#ifndef VKFW_INLINE +#ifdef __clang__ +#if __has_attribute(always_inline) +#define VKFW_INLINE __attribute__((always_inline)) __inline__ +#else +#define VKFW_INLINE inline +#endif +#elif defined(__GNUC__) +#define VKFW_INLINE __attribute__((always_inline)) __inline__ +#elif defined(_MSC_VER) +#define VKFW_INLINE inline +#else +#define VKFW_INLINE inline +#endif +#endif + +#ifdef __cpp_constexpr +#define VKFW_CONSTEXPR constexpr +#if __cpp_constexpr >= 201304 +#define VKFW_CONSTEXPR_14 constexpr +#else +#define VKFW_CONSTEXPR_14 +#endif +#define VKFW_CONST_OR_CONSTEXPR constexpr +#else +#define VKFW_CONSTEXPR +#define VKFW_CONSTEXPR_14 +#define VKFW_CONST_OR_CONSTEXPR const +#endif + +#ifndef VKFW_NOEXCEPT +#if defined(_MSC_VER) && (_MSC_VER <= 1800) +#define VKFW_NOEXCEPT +#else +#define VKFW_NOEXCEPT noexcept +#define VKFW_HAS_NOEXCEPT 1 +#endif +#endif + +#if 14 <= VKFW_CPP_VERSION +#define VKFW_DEPRECATED(msg) [[deprecated(msg)]] +#else +#define VKFW_DEPRECATED(msg) +#endif + +#if (17 <= VKFW_CPP_VERSION) && !defined(VKFW_NO_NODISCARD_WARNINGS) +#define VKFW_NODISCARD [[nodiscard]] +#ifdef VKFW_NO_EXCEPTIONS +#define VKFW_NODISCARD_WHEN_NO_EXCEPTIONS [[nodiscard]] +#else +#define VKFW_NODISCARD_WHEN_NO_EXCEPTIONS +#endif +#else +#define VKFW_NODISCARD +#define VKFW_NODISCARD_WHEN_NO_EXCEPTIONS +#endif + +#ifndef VKFW_NAMESPACE +#define VKFW_NAMESPACE vkfw +#endif + +#define VKFW_STRINGIFY2(text) #text +#define VKFW_STRINGIFY(text) VKFW_STRINGIFY2(text) +#define VKFW_NAMESPACE_STRING VKFW_STRINGIFY(VKFW_NAMESPACE) + +#ifdef VKFW_NO_LEADING_e_IN_ENUMS +#define VKFW_ENUMERATOR(name) name +#define VKFW_ENUMERATOR2(name_1, name_2) name_2 +#else +#define VKFW_ENUMERATOR(name) e##name +#define VKFW_ENUMERATOR2(name_1, name_2) e##name_1 +#endif + +namespace VKFW_NAMESPACE { + enum Boolean { VKFW_ENUMERATOR(True) = GLFW_TRUE, VKFW_ENUMERATOR(False) = GLFW_FALSE }; + enum class KeyAction { + VKFW_ENUMERATOR(Release) = GLFW_RELEASE, + VKFW_ENUMERATOR(Press) = GLFW_PRESS, + VKFW_ENUMERATOR(Repeat) = GLFW_REPEAT + }; + enum class MouseButtonAction { + VKFW_ENUMERATOR(Release) = GLFW_RELEASE, + VKFW_ENUMERATOR(Press) = GLFW_PRESS + }; + enum class JoystickHatState { + VKFW_ENUMERATOR(Centered) = GLFW_HAT_CENTERED, + VKFW_ENUMERATOR(Up) = GLFW_HAT_UP, + VKFW_ENUMERATOR(Right) = GLFW_HAT_RIGHT, + VKFW_ENUMERATOR(Down) = GLFW_HAT_DOWN, + VKFW_ENUMERATOR(Left) = GLFW_HAT_LEFT, + VKFW_ENUMERATOR(Right_Up) = GLFW_HAT_RIGHT_UP, + VKFW_ENUMERATOR(Right_Down) = GLFW_HAT_RIGHT_DOWN, + VKFW_ENUMERATOR(Left_Up) = GLFW_HAT_LEFT_UP, + VKFW_ENUMERATOR(Left_Down) = GLFW_HAT_LEFT_DOWN + }; + enum class Key { + /* The unknown Key */ + VKFW_ENUMERATOR(Unknown) = GLFW_KEY_UNKNOWN, + + /* Printable Keys */ + VKFW_ENUMERATOR(Space) = GLFW_KEY_SPACE, + VKFW_ENUMERATOR(Apostrophe) = GLFW_KEY_APOSTROPHE, /* ' */ + VKFW_ENUMERATOR(Comma) = GLFW_KEY_COMMA, /* , */ + VKFW_ENUMERATOR(Minus) = GLFW_KEY_MINUS, /* - */ + VKFW_ENUMERATOR(Period) = GLFW_KEY_PERIOD, /* . */ + VKFW_ENUMERATOR(Slash) = GLFW_KEY_SLASH, /* / */ + VKFW_ENUMERATOR2(0, _0) = GLFW_KEY_0, + VKFW_ENUMERATOR2(1, _1) = GLFW_KEY_1, + VKFW_ENUMERATOR2(2, _2) = GLFW_KEY_2, + VKFW_ENUMERATOR2(3, _3) = GLFW_KEY_3, + VKFW_ENUMERATOR2(4, _4) = GLFW_KEY_4, + VKFW_ENUMERATOR2(5, _5) = GLFW_KEY_5, + VKFW_ENUMERATOR2(6, _6) = GLFW_KEY_6, + VKFW_ENUMERATOR2(7, _7) = GLFW_KEY_7, + VKFW_ENUMERATOR2(8, _8) = GLFW_KEY_8, + VKFW_ENUMERATOR2(9, _9) = GLFW_KEY_9, + VKFW_ENUMERATOR(Semicolon) = GLFW_KEY_SEMICOLON, /* ; */ + VKFW_ENUMERATOR(Equal) = GLFW_KEY_EQUAL, /* = */ + VKFW_ENUMERATOR(A) = GLFW_KEY_A, + VKFW_ENUMERATOR(B) = GLFW_KEY_B, + VKFW_ENUMERATOR(C) = GLFW_KEY_C, + VKFW_ENUMERATOR(D) = GLFW_KEY_D, + VKFW_ENUMERATOR(E) = GLFW_KEY_E, + VKFW_ENUMERATOR(F) = GLFW_KEY_F, + VKFW_ENUMERATOR(G) = GLFW_KEY_G, + VKFW_ENUMERATOR(H) = GLFW_KEY_H, + VKFW_ENUMERATOR(I) = GLFW_KEY_I, + VKFW_ENUMERATOR(J) = GLFW_KEY_J, + VKFW_ENUMERATOR(K) = GLFW_KEY_K, + VKFW_ENUMERATOR(L) = GLFW_KEY_L, + VKFW_ENUMERATOR(M) = GLFW_KEY_M, + VKFW_ENUMERATOR(N) = GLFW_KEY_N, + VKFW_ENUMERATOR(O) = GLFW_KEY_O, + VKFW_ENUMERATOR(P) = GLFW_KEY_P, + VKFW_ENUMERATOR(Q) = GLFW_KEY_Q, + VKFW_ENUMERATOR(R) = GLFW_KEY_R, + VKFW_ENUMERATOR(S) = GLFW_KEY_S, + VKFW_ENUMERATOR(T) = GLFW_KEY_T, + VKFW_ENUMERATOR(U) = GLFW_KEY_U, + VKFW_ENUMERATOR(V) = GLFW_KEY_V, + VKFW_ENUMERATOR(W) = GLFW_KEY_W, + VKFW_ENUMERATOR(X) = GLFW_KEY_X, + VKFW_ENUMERATOR(Y) = GLFW_KEY_Y, + VKFW_ENUMERATOR(Z) = GLFW_KEY_Z, + VKFW_ENUMERATOR(LeftBracket) = GLFW_KEY_LEFT_BRACKET, /* [ */ + VKFW_ENUMERATOR(Backslash) = GLFW_KEY_BACKSLASH, /* \ */ + VKFW_ENUMERATOR(RightBracket) = GLFW_KEY_RIGHT_BRACKET, /* ] */ + VKFW_ENUMERATOR(GraveAccent) = GLFW_KEY_GRAVE_ACCENT, /* ` */ + VKFW_ENUMERATOR(World1) = GLFW_KEY_WORLD_1, /* non-US #1 */ + VKFW_ENUMERATOR(World2) = GLFW_KEY_WORLD_2, /* non-US #2 */ + + /* Function Keys */ + VKFW_ENUMERATOR(Escape) = GLFW_KEY_ESCAPE, + VKFW_ENUMERATOR(Enter) = GLFW_KEY_ENTER, + VKFW_ENUMERATOR(Tab) = GLFW_KEY_TAB, + VKFW_ENUMERATOR(Backspace) = GLFW_KEY_BACKSPACE, + VKFW_ENUMERATOR(Insert) = GLFW_KEY_INSERT, + VKFW_ENUMERATOR(Delete) = GLFW_KEY_DELETE, + VKFW_ENUMERATOR(Right) = GLFW_KEY_RIGHT, + VKFW_ENUMERATOR(Left) = GLFW_KEY_LEFT, + VKFW_ENUMERATOR(Down) = GLFW_KEY_DOWN, + VKFW_ENUMERATOR(Up) = GLFW_KEY_UP, + VKFW_ENUMERATOR(PageUp) = GLFW_KEY_PAGE_UP, + VKFW_ENUMERATOR(PageDown) = GLFW_KEY_PAGE_DOWN, + VKFW_ENUMERATOR(Home) = GLFW_KEY_HOME, + VKFW_ENUMERATOR(End) = GLFW_KEY_END, + VKFW_ENUMERATOR(CapsLock) = GLFW_KEY_CAPS_LOCK, + VKFW_ENUMERATOR(ScrollLock) = GLFW_KEY_SCROLL_LOCK, + VKFW_ENUMERATOR(NumLock) = GLFW_KEY_NUM_LOCK, + VKFW_ENUMERATOR(PrintScreen) = GLFW_KEY_PRINT_SCREEN, + VKFW_ENUMERATOR(Pause) = GLFW_KEY_PAUSE, + VKFW_ENUMERATOR(F1) = GLFW_KEY_F1, + VKFW_ENUMERATOR(F2) = GLFW_KEY_F2, + VKFW_ENUMERATOR(F3) = GLFW_KEY_F3, + VKFW_ENUMERATOR(F4) = GLFW_KEY_F4, + VKFW_ENUMERATOR(F5) = GLFW_KEY_F5, + VKFW_ENUMERATOR(F6) = GLFW_KEY_F6, + VKFW_ENUMERATOR(F7) = GLFW_KEY_F7, + VKFW_ENUMERATOR(F8) = GLFW_KEY_F8, + VKFW_ENUMERATOR(F9) = GLFW_KEY_F9, + VKFW_ENUMERATOR(F10) = GLFW_KEY_F10, + VKFW_ENUMERATOR(F11) = GLFW_KEY_F11, + VKFW_ENUMERATOR(F12) = GLFW_KEY_F12, + VKFW_ENUMERATOR(F13) = GLFW_KEY_F13, + VKFW_ENUMERATOR(F14) = GLFW_KEY_F14, + VKFW_ENUMERATOR(F15) = GLFW_KEY_F15, + VKFW_ENUMERATOR(F16) = GLFW_KEY_F16, + VKFW_ENUMERATOR(F17) = GLFW_KEY_F17, + VKFW_ENUMERATOR(F18) = GLFW_KEY_F18, + VKFW_ENUMERATOR(F19) = GLFW_KEY_F19, + VKFW_ENUMERATOR(F20) = GLFW_KEY_F20, + VKFW_ENUMERATOR(F21) = GLFW_KEY_F21, + VKFW_ENUMERATOR(F22) = GLFW_KEY_F22, + VKFW_ENUMERATOR(F23) = GLFW_KEY_F23, + VKFW_ENUMERATOR(F24) = GLFW_KEY_F24, + VKFW_ENUMERATOR(F25) = GLFW_KEY_F25, + VKFW_ENUMERATOR(KeyPad_0) = GLFW_KEY_KP_0, + VKFW_ENUMERATOR(KeyPad_1) = GLFW_KEY_KP_1, + VKFW_ENUMERATOR(KeyPad_2) = GLFW_KEY_KP_2, + VKFW_ENUMERATOR(KeyPad_3) = GLFW_KEY_KP_3, + VKFW_ENUMERATOR(KeyPad_4) = GLFW_KEY_KP_4, + VKFW_ENUMERATOR(KeyPad_5) = GLFW_KEY_KP_5, + VKFW_ENUMERATOR(KeyPad_6) = GLFW_KEY_KP_6, + VKFW_ENUMERATOR(KeyPad_7) = GLFW_KEY_KP_7, + VKFW_ENUMERATOR(KeyPad_8) = GLFW_KEY_KP_8, + VKFW_ENUMERATOR(KeyPad_9) = GLFW_KEY_KP_9, + VKFW_ENUMERATOR(KeyPad_Decimal) = GLFW_KEY_KP_DECIMAL, + VKFW_ENUMERATOR(KeyPad_Divide) = GLFW_KEY_KP_DIVIDE, + VKFW_ENUMERATOR(KeyPad_Multiply) = GLFW_KEY_KP_MULTIPLY, + VKFW_ENUMERATOR(KeyPad_Subtract) = GLFW_KEY_KP_SUBTRACT, + VKFW_ENUMERATOR(KeyPad_Add) = GLFW_KEY_KP_ADD, + VKFW_ENUMERATOR(KeyPad_Enter) = GLFW_KEY_KP_ENTER, + VKFW_ENUMERATOR(KeyPad_Equal) = GLFW_KEY_KP_EQUAL, + VKFW_ENUMERATOR(LeftShift) = GLFW_KEY_LEFT_SHIFT, + VKFW_ENUMERATOR(LeftControl) = GLFW_KEY_LEFT_CONTROL, + VKFW_ENUMERATOR(LeftAlt) = GLFW_KEY_LEFT_ALT, + VKFW_ENUMERATOR(LeftSuper) = GLFW_KEY_LEFT_SUPER, + VKFW_ENUMERATOR(RightShift) = GLFW_KEY_RIGHT_SHIFT, + VKFW_ENUMERATOR(RightControl) = GLFW_KEY_RIGHT_CONTROL, + VKFW_ENUMERATOR(RightAlt) = GLFW_KEY_RIGHT_ALT, + VKFW_ENUMERATOR(RightSuper) = GLFW_KEY_RIGHT_SUPER, + VKFW_ENUMERATOR(Menu) = GLFW_KEY_MENU, + + VKFW_ENUMERATOR(LAST) = GLFW_KEY_LAST + }; + enum class MouseButton { + VKFW_ENUMERATOR2(1, _1) = GLFW_MOUSE_BUTTON_1, + VKFW_ENUMERATOR2(2, _2) = GLFW_MOUSE_BUTTON_2, + VKFW_ENUMERATOR2(3, _3) = GLFW_MOUSE_BUTTON_3, + VKFW_ENUMERATOR2(4, _4) = GLFW_MOUSE_BUTTON_4, + VKFW_ENUMERATOR2(5, _5) = GLFW_MOUSE_BUTTON_5, + VKFW_ENUMERATOR2(6, _6) = GLFW_MOUSE_BUTTON_6, + VKFW_ENUMERATOR2(7, _7) = GLFW_MOUSE_BUTTON_7, + VKFW_ENUMERATOR2(8, _8) = GLFW_MOUSE_BUTTON_8, + + VKFW_ENUMERATOR(Left) = GLFW_MOUSE_BUTTON_LEFT, + VKFW_ENUMERATOR(Right) = GLFW_MOUSE_BUTTON_RIGHT, + VKFW_ENUMERATOR(Middle) = GLFW_MOUSE_BUTTON_MIDDLE, + + VKFW_ENUMERATOR(LAST) = GLFW_MOUSE_BUTTON_LAST + }; + enum class Joystick { + VKFW_ENUMERATOR2(1, _1) = GLFW_JOYSTICK_1, + VKFW_ENUMERATOR2(2, _2) = GLFW_JOYSTICK_2, + VKFW_ENUMERATOR2(3, _3) = GLFW_JOYSTICK_3, + VKFW_ENUMERATOR2(4, _4) = GLFW_JOYSTICK_4, + VKFW_ENUMERATOR2(5, _5) = GLFW_JOYSTICK_5, + VKFW_ENUMERATOR2(6, _6) = GLFW_JOYSTICK_6, + VKFW_ENUMERATOR2(7, _7) = GLFW_JOYSTICK_7, + VKFW_ENUMERATOR2(8, _8) = GLFW_JOYSTICK_8, + VKFW_ENUMERATOR2(9, _9) = GLFW_JOYSTICK_9, + VKFW_ENUMERATOR2(10, _10) = GLFW_JOYSTICK_10, + VKFW_ENUMERATOR2(11, _11) = GLFW_JOYSTICK_11, + VKFW_ENUMERATOR2(12, _12) = GLFW_JOYSTICK_12, + VKFW_ENUMERATOR2(13, _13) = GLFW_JOYSTICK_13, + VKFW_ENUMERATOR2(14, _14) = GLFW_JOYSTICK_14, + VKFW_ENUMERATOR2(15, _15) = GLFW_JOYSTICK_15, + VKFW_ENUMERATOR2(16, _16) = GLFW_JOYSTICK_16, + + VKFW_ENUMERATOR(LAST) = GLFW_JOYSTICK_LAST + }; + enum class GamepadButton { + VKFW_ENUMERATOR(A) = GLFW_GAMEPAD_BUTTON_A, + VKFW_ENUMERATOR(B) = GLFW_GAMEPAD_BUTTON_B, + VKFW_ENUMERATOR(X) = GLFW_GAMEPAD_BUTTON_X, + VKFW_ENUMERATOR(Y) = GLFW_GAMEPAD_BUTTON_Y, + VKFW_ENUMERATOR(LeftBumper) = GLFW_GAMEPAD_BUTTON_LEFT_BUMPER, + VKFW_ENUMERATOR(RightBumper) = GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER, + VKFW_ENUMERATOR(Back) = GLFW_GAMEPAD_BUTTON_BACK, + VKFW_ENUMERATOR(Start) = GLFW_GAMEPAD_BUTTON_START, + VKFW_ENUMERATOR(Guide) = GLFW_GAMEPAD_BUTTON_GUIDE, + VKFW_ENUMERATOR(LeftThumb) = GLFW_GAMEPAD_BUTTON_LEFT_THUMB, + VKFW_ENUMERATOR(RightThumb) = GLFW_GAMEPAD_BUTTON_RIGHT_THUMB, + VKFW_ENUMERATOR(DpadUp) = GLFW_GAMEPAD_BUTTON_DPAD_UP, + VKFW_ENUMERATOR(DpadRight) = GLFW_GAMEPAD_BUTTON_DPAD_RIGHT, + VKFW_ENUMERATOR(DpadDown) = GLFW_GAMEPAD_BUTTON_DPAD_DOWN, + VKFW_ENUMERATOR(DpadLeft) = GLFW_GAMEPAD_BUTTON_DPAD_LEFT, + + VKFW_ENUMERATOR(Cross) = GLFW_GAMEPAD_BUTTON_CROSS, + VKFW_ENUMERATOR(Circle) = GLFW_GAMEPAD_BUTTON_CIRCLE, + VKFW_ENUMERATOR(Square) = GLFW_GAMEPAD_BUTTON_SQUARE, + VKFW_ENUMERATOR(Triangle) = GLFW_GAMEPAD_BUTTON_TRIANGLE, + + VKFW_ENUMERATOR(LAST) = GLFW_GAMEPAD_BUTTON_LAST + }; + enum class GamepadAxis { + VKFW_ENUMERATOR(LeftX) = GLFW_GAMEPAD_AXIS_LEFT_X, + VKFW_ENUMERATOR(LeftY) = GLFW_GAMEPAD_AXIS_LEFT_Y, + VKFW_ENUMERATOR(RightX) = GLFW_GAMEPAD_AXIS_RIGHT_X, + VKFW_ENUMERATOR(RightY) = GLFW_GAMEPAD_AXIS_RIGHT_Y, + VKFW_ENUMERATOR(LeftTrigger) = GLFW_GAMEPAD_AXIS_LEFT_TRIGGER, + VKFW_ENUMERATOR(RightTrigger) = GLFW_GAMEPAD_AXIS_RIGHT_TRIGGER, + + VKFW_ENUMERATOR(LAST) = GLFW_GAMEPAD_AXIS_LAST + }; + enum class Result { + VKFW_ENUMERATOR(Success) = GLFW_NO_ERROR, + VKFW_ENUMERATOR(NotInitialized) = GLFW_NOT_INITIALIZED, + VKFW_ENUMERATOR(NoCurrentContext) = GLFW_NO_CURRENT_CONTEXT, + VKFW_ENUMERATOR(InvalidEnum) = GLFW_INVALID_ENUM, + VKFW_ENUMERATOR(InvalidValue) = GLFW_INVALID_VALUE, + VKFW_ENUMERATOR(OutOfMemory) = GLFW_OUT_OF_MEMORY, + VKFW_ENUMERATOR(ApiUnavailable) = GLFW_API_UNAVAILABLE, + VKFW_ENUMERATOR(VersionUnavailable) = GLFW_VERSION_UNAVAILABLE, + VKFW_ENUMERATOR(PlatformError) = GLFW_PLATFORM_ERROR, + VKFW_ENUMERATOR(FormatUnavailable) = GLFW_FORMAT_UNAVAILABLE, + VKFW_ENUMERATOR(NoWindowContext) = GLFW_NO_WINDOW_CONTEXT, + VKFW_ENUMERATOR(CursorUnavailable) = GLFW_CURSOR_UNAVAILABLE, + VKFW_ENUMERATOR(FeatureUnavailable) = GLFW_FEATURE_UNAVAILABLE, + VKFW_ENUMERATOR(FeatureUnimplemented) = GLFW_FEATURE_UNIMPLEMENTED, + VKFW_ENUMERATOR(PlatformUnavailable) = GLFW_PLATFORM_UNAVAILABLE + }; + VKFW_INLINE VKFW_CONSTEXPR bool check(Result result) { return result == Result::VKFW_ENUMERATOR(Success); } + enum class Platform { + VKFW_ENUMERATOR(Any) = GLFW_ANY_PLATFORM, + VKFW_ENUMERATOR(Win32) = GLFW_PLATFORM_WIN32, + VKFW_ENUMERATOR(Cocoa) = GLFW_PLATFORM_COCOA, + VKFW_ENUMERATOR(Wayland) = GLFW_PLATFORM_WAYLAND, + VKFW_ENUMERATOR(X11) = GLFW_PLATFORM_X11, + VKFW_ENUMERATOR(Null) = GLFW_PLATFORM_NULL + }; + enum class AnglePlatformType { + VKFW_ENUMERATOR(None) = GLFW_ANGLE_PLATFORM_TYPE_NONE, + VKFW_ENUMERATOR(OpenGL) = GLFW_ANGLE_PLATFORM_TYPE_OPENGL, + VKFW_ENUMERATOR(OpenGLES) = GLFW_ANGLE_PLATFORM_TYPE_OPENGLES, + VKFW_ENUMERATOR(D3D9) = GLFW_ANGLE_PLATFORM_TYPE_D3D9, + VKFW_ENUMERATOR(D3D11) = GLFW_ANGLE_PLATFORM_TYPE_D3D11, + VKFW_ENUMERATOR(Vulkan) = GLFW_ANGLE_PLATFORM_TYPE_VULKAN, + VKFW_ENUMERATOR(Metal) = GLFW_ANGLE_PLATFORM_TYPE_METAL + }; + enum class WaylandLibDecor { + VKFW_ENUMERATOR(Prefer) = GLFW_WAYLAND_PREFER_LIBDECOR, + VKFW_ENUMERATOR(Disable) = GLFW_WAYLAND_DISABLE_LIBDECOR + }; + enum class InitializationHint { + VKFW_ENUMERATOR(Platform) = GLFW_PLATFORM, + VKFW_ENUMERATOR(JoystickHatButtons) = GLFW_JOYSTICK_HAT_BUTTONS, + VKFW_ENUMERATOR(AnglePlatformType) = GLFW_ANGLE_PLATFORM_TYPE, + + // MacOS specific + VKFW_ENUMERATOR(CocoaChdirResources) = GLFW_COCOA_CHDIR_RESOURCES, + VKFW_ENUMERATOR(CocoaMenubar) = GLFW_COCOA_MENUBAR, + + // Wayland specific + VKFW_ENUMERATOR(WaylandLibDecor) = GLFW_WAYLAND_LIBDECOR, + + // X11 specific + VKFW_ENUMERATOR(X11XCBVulkanSurface) = GLFW_X11_XCB_VULKAN_SURFACE + }; + VKFW_CONSTEXPR VKFW_INLINE unsigned AnyPosition = GLFW_ANY_POSITION; + enum class WindowHint { + + // Window Hints + VKFW_ENUMERATOR(Focused) = GLFW_FOCUSED, + VKFW_ENUMERATOR(Resizable) = GLFW_RESIZABLE, + VKFW_ENUMERATOR(Visible) = GLFW_VISIBLE, + VKFW_ENUMERATOR(Decorated) = GLFW_DECORATED, + VKFW_ENUMERATOR(AutoIconify) = GLFW_AUTO_ICONIFY, + VKFW_ENUMERATOR(Floating) = GLFW_FLOATING, + VKFW_ENUMERATOR(Maximized) = GLFW_MAXIMIZED, + VKFW_ENUMERATOR(CenterCursor) = GLFW_CENTER_CURSOR, + VKFW_ENUMERATOR(TransparentFramebuffer) = GLFW_TRANSPARENT_FRAMEBUFFER, + VKFW_ENUMERATOR(FocusOnShow) = GLFW_FOCUS_ON_SHOW, + VKFW_ENUMERATOR(MousePassthrough) = GLFW_MOUSE_PASSTHROUGH, + VKFW_ENUMERATOR(PositionX) = GLFW_POSITION_X, + VKFW_ENUMERATOR(PositionY) = GLFW_POSITION_Y, + + // Framebuffer Hints + VKFW_ENUMERATOR(RedBits) = GLFW_RED_BITS, + VKFW_ENUMERATOR(GreenBits) = GLFW_GREEN_BITS, + VKFW_ENUMERATOR(BlueBits) = GLFW_BLUE_BITS, + VKFW_ENUMERATOR(AlphaBits) = GLFW_ALPHA_BITS, + VKFW_ENUMERATOR(DepthBits) = GLFW_DEPTH_BITS, + VKFW_ENUMERATOR(StencilBits) = GLFW_STENCIL_BITS, + VKFW_ENUMERATOR(AccumulationRedBits) = GLFW_ACCUM_RED_BITS, + VKFW_ENUMERATOR(AccumulationGreenBits) = GLFW_ACCUM_GREEN_BITS, + VKFW_ENUMERATOR(AccumulationBlueBits) = GLFW_ACCUM_BLUE_BITS, + VKFW_ENUMERATOR(AccumulationAlphaBits) = GLFW_ACCUM_ALPHA_BITS, + VKFW_ENUMERATOR(AuxiliaryBuffers) = GLFW_AUX_BUFFERS, + VKFW_ENUMERATOR(StereoscopicRendering) = GLFW_STEREO, + VKFW_ENUMERATOR(Samples) = GLFW_SAMPLES, + VKFW_ENUMERATOR(SRGBCapable) = GLFW_SRGB_CAPABLE, + VKFW_ENUMERATOR(RefreshRate) = GLFW_REFRESH_RATE, + + VKFW_ENUMERATOR(ScaleToMonitor) = GLFW_SCALE_TO_MONITOR, + VKFW_ENUMERATOR(ScaleFramebuffer) = GLFW_SCALE_FRAMEBUFFER, + + // Context client API Hints + VKFW_ENUMERATOR(DoubleBuffer) = GLFW_DOUBLEBUFFER, + VKFW_ENUMERATOR(ClientAPI) = GLFW_CLIENT_API, + VKFW_ENUMERATOR(ContextVersionMajor) = GLFW_CONTEXT_VERSION_MAJOR, + VKFW_ENUMERATOR(ContextVersionMinor) = GLFW_CONTEXT_VERSION_MINOR, + // VKFW_ENUMERATOR(ContextRevision) = GLFW_CONTEXT_REVISION, + VKFW_ENUMERATOR(ContextRobustness) = GLFW_CONTEXT_ROBUSTNESS, + VKFW_ENUMERATOR(OpenGLForwardCompatibility) = GLFW_OPENGL_FORWARD_COMPAT, + VKFW_ENUMERATOR(OpenGLDebugContext) = GLFW_OPENGL_DEBUG_CONTEXT, + VKFW_ENUMERATOR(OpenGLProfile) = GLFW_OPENGL_PROFILE, + VKFW_ENUMERATOR(ContextReleaseBehavior) = GLFW_CONTEXT_RELEASE_BEHAVIOR, + VKFW_ENUMERATOR(ContextNoError) = GLFW_CONTEXT_NO_ERROR, + VKFW_ENUMERATOR(ContextCreationAPI) = GLFW_CONTEXT_CREATION_API, + + // Win32 specific Hints + VKFW_ENUMERATOR(Win32KeyboardMenu) = GLFW_WIN32_KEYBOARD_MENU, + VKFW_ENUMERATOR(Win32ShowDefault) = GLFW_WIN32_SHOWDEFAULT, + + // MacOS specific Hints + VKFW_ENUMERATOR(CocoaRetinaFramebuffer) = GLFW_COCOA_RETINA_FRAMEBUFFER, + VKFW_ENUMERATOR(CocoaFrameName) = GLFW_COCOA_FRAME_NAME, + VKFW_ENUMERATOR(CocoaGraphicsSwitching) = GLFW_COCOA_GRAPHICS_SWITCHING, + + // X11 specific Hints + VKFW_ENUMERATOR(X11ClassName) = GLFW_X11_CLASS_NAME, + VKFW_ENUMERATOR(X11InstanceName) = GLFW_X11_INSTANCE_NAME, + + // Wayland specific Hints + VKFW_ENUMERATOR(WaylandAppID) = GLFW_WAYLAND_APP_ID + }; + enum class Attribute { + // Window Attributes + VKFW_ENUMERATOR(Focused) = GLFW_FOCUSED, + VKFW_ENUMERATOR(Iconified) = GLFW_ICONIFIED, + VKFW_ENUMERATOR(Resizable) = GLFW_RESIZABLE, + VKFW_ENUMERATOR(Visible) = GLFW_VISIBLE, + VKFW_ENUMERATOR(Decorated) = GLFW_DECORATED, + VKFW_ENUMERATOR(AutoIconify) = GLFW_AUTO_ICONIFY, + VKFW_ENUMERATOR(Floating) = GLFW_FLOATING, + VKFW_ENUMERATOR(Maximized) = GLFW_MAXIMIZED, + VKFW_ENUMERATOR(TransparentFramebuffer) = GLFW_TRANSPARENT_FRAMEBUFFER, + VKFW_ENUMERATOR(Hovered) = GLFW_HOVERED, + VKFW_ENUMERATOR(FocusOnShow) = GLFW_FOCUS_ON_SHOW, + VKFW_ENUMERATOR(MousePassthrough) = GLFW_MOUSE_PASSTHROUGH, + + // Context client API Attributes + VKFW_ENUMERATOR(ClientAPI) = GLFW_CLIENT_API, + VKFW_ENUMERATOR(ContextVersionMajor) = GLFW_CONTEXT_VERSION_MAJOR, + VKFW_ENUMERATOR(ContextVersionMinor) = GLFW_CONTEXT_VERSION_MINOR, + VKFW_ENUMERATOR(ContextRevision) = GLFW_CONTEXT_REVISION, + VKFW_ENUMERATOR(ContextRobustness) = GLFW_CONTEXT_ROBUSTNESS, + VKFW_ENUMERATOR(OpenGLForwardCompatibility) = GLFW_OPENGL_FORWARD_COMPAT, + VKFW_ENUMERATOR(OpenGLDebugContext) = GLFW_OPENGL_DEBUG_CONTEXT, + VKFW_ENUMERATOR(OpenGLProfile) = GLFW_OPENGL_PROFILE, + VKFW_ENUMERATOR(ContextReleaseBehavior) = GLFW_CONTEXT_RELEASE_BEHAVIOR, + VKFW_ENUMERATOR(ContextNoError) = GLFW_CONTEXT_NO_ERROR, + VKFW_ENUMERATOR(ContextCreationAPI) = GLFW_CONTEXT_CREATION_API, + }; + using WindowAttribute = Attribute; + + enum class ClientAPI { + VKFW_ENUMERATOR(None) = GLFW_NO_API, + VKFW_ENUMERATOR(OpenGL) = GLFW_OPENGL_API, + VKFW_ENUMERATOR(OpenGL_ES) = GLFW_OPENGL_ES_API + }; + enum class ContextRobustness { + VKFW_ENUMERATOR(None) = GLFW_NO_ROBUSTNESS, + VKFW_ENUMERATOR(NoResetNotification) = GLFW_NO_RESET_NOTIFICATION, + VKFW_ENUMERATOR(LoseContextOnReset) = GLFW_LOSE_CONTEXT_ON_RESET + }; + enum class OpenGLProfile { + VKFW_ENUMERATOR(Any) = GLFW_OPENGL_ANY_PROFILE, + VKFW_ENUMERATOR(Core) = GLFW_OPENGL_CORE_PROFILE, + VKFW_ENUMERATOR(Compatibility) = GLFW_OPENGL_COMPAT_PROFILE + }; + enum class InputMode { + VKFW_ENUMERATOR(Cursor) = GLFW_CURSOR, + VKFW_ENUMERATOR(StickyKeys) = GLFW_STICKY_KEYS, + VKFW_ENUMERATOR(StickyMouseButtons) = GLFW_STICKY_MOUSE_BUTTONS, + VKFW_ENUMERATOR(LockKeyModifiers) = GLFW_LOCK_KEY_MODS, + VKFW_ENUMERATOR(RawMouseMotion) = GLFW_RAW_MOUSE_MOTION + }; + enum class CursorMode { + VKFW_ENUMERATOR(Normal) = GLFW_CURSOR_NORMAL, + VKFW_ENUMERATOR(Hidden) = GLFW_CURSOR_HIDDEN, + VKFW_ENUMERATOR(Disabled) = GLFW_CURSOR_DISABLED, + VKFW_ENUMERATOR(Captured) = GLFW_CURSOR_CAPTURED + }; + enum class ContextReleaseBehavior { + VKFW_ENUMERATOR(Any) = GLFW_ANY_RELEASE_BEHAVIOR, + VKFW_ENUMERATOR(Flush) = GLFW_RELEASE_BEHAVIOR_FLUSH, + VKFW_ENUMERATOR(None) = GLFW_RELEASE_BEHAVIOR_NONE + }; + enum class ContextCreationAPI { + VKFW_ENUMERATOR(Native) = GLFW_NATIVE_CONTEXT_API, + VKFW_ENUMERATOR(EGL) = GLFW_EGL_CONTEXT_API, + VKFW_ENUMERATOR(OSMESA) = GLFW_OSMESA_CONTEXT_API + }; + enum class CursorShape { + VKFW_ENUMERATOR(Arrow) = GLFW_ARROW_CURSOR, + VKFW_ENUMERATOR(IBeam) = GLFW_IBEAM_CURSOR, + VKFW_ENUMERATOR(Crosshair) = GLFW_CROSSHAIR_CURSOR, + VKFW_ENUMERATOR(PointingHand) = GLFW_POINTING_HAND_CURSOR, + VKFW_ENUMERATOR(ResizeEW) = GLFW_RESIZE_EW_CURSOR, + VKFW_ENUMERATOR(ResizeNS) = GLFW_RESIZE_NS_CURSOR, + VKFW_ENUMERATOR(ResizeNWSE) = GLFW_RESIZE_NWSE_CURSOR, + VKFW_ENUMERATOR(ResizeNESW) = GLFW_RESIZE_NESW_CURSOR, + VKFW_ENUMERATOR(ResizeAll) = GLFW_RESIZE_ALL_CURSOR, + VKFW_ENUMERATOR(NotAllowed) = GLFW_NOT_ALLOWED_CURSOR, + + // Legacy + VKFW_ENUMERATOR(HResize) = VKFW_ENUMERATOR(ResizeEW), + VKFW_ENUMERATOR(VResize) = VKFW_ENUMERATOR(ResizeNS), + VKFW_ENUMERATOR(Hand) = VKFW_ENUMERATOR(PointingHand) + }; + enum class Status { + VKFW_ENUMERATOR(Connected) = GLFW_CONNECTED, + VKFW_ENUMERATOR(Disconnected) = GLFW_DISCONNECTED + }; + enum DontCare : unsigned { + DontCare = unsigned(GLFW_DONT_CARE) +#ifndef VKFW_NO_LEADING_e_IN_ENUMS + , + eDontCare = unsigned(GLFW_DONT_CARE) +#endif + }; + + enum class ModifierKeyBits { + VKFW_ENUMERATOR(Shift) = GLFW_MOD_SHIFT, + VKFW_ENUMERATOR(Control) = GLFW_MOD_CONTROL, + VKFW_ENUMERATOR(Alt) = GLFW_MOD_ALT, + VKFW_ENUMERATOR(Super) = GLFW_MOD_SUPER, + VKFW_ENUMERATOR(CapsLock) = GLFW_MOD_CAPS_LOCK, + VKFW_ENUMERATOR(NumLock) = GLFW_MOD_NUM_LOCK + }; + class ModifierKeyFlags { + public: + using MaskType = typename std::underlying_type::type; + enum class traits : MaskType { + allFlags = MaskType(VKFW_NAMESPACE::ModifierKeyBits::VKFW_ENUMERATOR(Shift)) | + MaskType(VKFW_NAMESPACE::ModifierKeyBits::VKFW_ENUMERATOR(Control)) | + MaskType(VKFW_NAMESPACE::ModifierKeyBits::VKFW_ENUMERATOR(Alt)) | + MaskType(VKFW_NAMESPACE::ModifierKeyBits::VKFW_ENUMERATOR(Super)) | + MaskType(VKFW_NAMESPACE::ModifierKeyBits::VKFW_ENUMERATOR(CapsLock)) | + MaskType(VKFW_NAMESPACE::ModifierKeyBits::VKFW_ENUMERATOR(NumLock)) + }; + + VKFW_CONSTEXPR ModifierKeyFlags() VKFW_NOEXCEPT : m_mask(0) {} + VKFW_CONSTEXPR ModifierKeyFlags(ModifierKeyBits bit) VKFW_NOEXCEPT : m_mask(static_cast(bit)) {} + VKFW_CONSTEXPR ModifierKeyFlags(ModifierKeyFlags const& rhs) VKFW_NOEXCEPT : m_mask(rhs.m_mask) {} + VKFW_CONSTEXPR explicit ModifierKeyFlags(MaskType flags) VKFW_NOEXCEPT : m_mask(flags) {} + +#ifdef VKFW_HAS_SPACESHIP_OPERATOR + auto operator<=>(ModifierKeyFlags const&) const = default; +#else + VKFW_CONSTEXPR bool operator<(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return m_mask < rhs.m_mask; + } + VKFW_CONSTEXPR bool operator<=(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return m_mask <= rhs.m_mask; + } + VKFW_CONSTEXPR bool operator>(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return m_mask > rhs.m_mask; + } + VKFW_CONSTEXPR bool operator>=(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return m_mask >= rhs.m_mask; + } + VKFW_CONSTEXPR bool operator==(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return m_mask == rhs.m_mask; + } + VKFW_CONSTEXPR bool operator!=(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return m_mask != rhs.m_mask; + } +#endif + VKFW_CONSTEXPR bool operator!() const VKFW_NOEXCEPT { return !m_mask; } + VKFW_CONSTEXPR ModifierKeyFlags operator&(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return ModifierKeyFlags(m_mask & rhs.m_mask); + } + VKFW_CONSTEXPR ModifierKeyFlags operator|(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return ModifierKeyFlags(m_mask | rhs.m_mask); + } + VKFW_CONSTEXPR ModifierKeyFlags operator^(ModifierKeyFlags const& rhs) const VKFW_NOEXCEPT { + return ModifierKeyFlags(m_mask ^ rhs.m_mask); + } + VKFW_CONSTEXPR ModifierKeyFlags operator~() const VKFW_NOEXCEPT { + return ModifierKeyFlags(m_mask ^ static_cast(traits::allFlags)); + } + + VKFW_CONSTEXPR_14 ModifierKeyFlags& operator=(ModifierKeyFlags const& rhs) VKFW_NOEXCEPT { + m_mask = rhs.m_mask; + return *this; + } + VKFW_CONSTEXPR_14 ModifierKeyFlags& operator|=(ModifierKeyFlags const& rhs) VKFW_NOEXCEPT { + m_mask |= rhs.m_mask; + return *this; + } + VKFW_CONSTEXPR_14 ModifierKeyFlags& operator&=(ModifierKeyFlags const& rhs) VKFW_NOEXCEPT { + m_mask &= rhs.m_mask; + return *this; + } + VKFW_CONSTEXPR_14 ModifierKeyFlags& operator^=(ModifierKeyFlags const& rhs) VKFW_NOEXCEPT { + m_mask ^= rhs.m_mask; + return *this; + } + + explicit VKFW_CONSTEXPR operator bool() const VKFW_NOEXCEPT { return !!m_mask; } + explicit VKFW_CONSTEXPR operator MaskType() const VKFW_NOEXCEPT { return m_mask; } + + private: + MaskType m_mask; + }; +#if !defined(VKFW_HAS_SPACESHIP_OPERATOR) + template + VKFW_CONSTEXPR bool operator<(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT { + return flags > bit; + } + template + VKFW_CONSTEXPR bool operator<=(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT { + return flags >= bit; + } + template + VKFW_CONSTEXPR bool operator>(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT { + return flags < bit; + } + template + VKFW_CONSTEXPR bool operator>=(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT { + return flags <= bit; + } + template + VKFW_CONSTEXPR bool operator==(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT { + return flags == bit; + } + template + VKFW_CONSTEXPR bool operator!=(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT { + return flags != bit; + } +#endif + VKFW_CONSTEXPR ModifierKeyFlags operator&(ModifierKeyBits bit, ModifierKeyFlags const& flags) + VKFW_NOEXCEPT { + return flags & bit; + } + VKFW_CONSTEXPR ModifierKeyFlags operator|(ModifierKeyBits bit, ModifierKeyFlags const& flags) + VKFW_NOEXCEPT { + return flags | bit; + } + VKFW_CONSTEXPR ModifierKeyFlags operator^(ModifierKeyBits bit, ModifierKeyFlags const& flags) + VKFW_NOEXCEPT { + return flags ^ bit; + } + VKFW_INLINE VKFW_CONSTEXPR ModifierKeyFlags operator|(ModifierKeyBits bit0, ModifierKeyBits bit1) + VKFW_NOEXCEPT { + return ModifierKeyFlags(bit0) | bit1; + } + VKFW_INLINE VKFW_CONSTEXPR ModifierKeyFlags operator&(ModifierKeyBits bit0, ModifierKeyBits bit1) + VKFW_NOEXCEPT { + return ModifierKeyFlags(bit0) & bit1; + } + VKFW_INLINE VKFW_CONSTEXPR ModifierKeyFlags operator^(ModifierKeyBits bit0, ModifierKeyBits bit1) + VKFW_NOEXCEPT { + return ModifierKeyFlags(bit0) ^ bit1; + } + VKFW_INLINE VKFW_CONSTEXPR ModifierKeyFlags operator~(ModifierKeyBits bits) VKFW_NOEXCEPT { + return ~(ModifierKeyFlags(bits)); + } + + VKFW_INLINE std::string to_string(Boolean value) { + switch (value) { + case Boolean::VKFW_ENUMERATOR(True): + return "True"; + case Boolean::VKFW_ENUMERATOR(False): + return "False"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(KeyAction value) { + switch (value) { + case KeyAction::VKFW_ENUMERATOR(Release): + return "Release"; + case KeyAction::VKFW_ENUMERATOR(Press): + return "Press"; + case KeyAction::VKFW_ENUMERATOR(Repeat): + return "Repeat"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(MouseButtonAction value) { + switch (value) { + case MouseButtonAction::VKFW_ENUMERATOR(Release): + return "Release"; + case MouseButtonAction::VKFW_ENUMERATOR(Press): + return "Press"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(JoystickHatState value) { + switch (value) { + case JoystickHatState::VKFW_ENUMERATOR(Centered): + return "Centered"; + case JoystickHatState::VKFW_ENUMERATOR(Up): + return "Up"; + case JoystickHatState::VKFW_ENUMERATOR(Right): + return "Right"; + case JoystickHatState::VKFW_ENUMERATOR(Down): + return "Down"; + case JoystickHatState::VKFW_ENUMERATOR(Left): + return "Left"; + case JoystickHatState::VKFW_ENUMERATOR(Right_Up): + return "Right Up"; + case JoystickHatState::VKFW_ENUMERATOR(Right_Down): + return "Right Down"; + case JoystickHatState::VKFW_ENUMERATOR(Left_Up): + return "Left Up"; + case JoystickHatState::VKFW_ENUMERATOR(Left_Down): + return "Left Down"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(Key value) { + switch (value) { + case Key::VKFW_ENUMERATOR(Unknown): + return "Unknown"; + + /* + * Printable Keys + */ + case Key::VKFW_ENUMERATOR(Space): + return "Space"; + case Key::VKFW_ENUMERATOR(Apostrophe): + return "Apostrophe"; + case Key::VKFW_ENUMERATOR(Comma): + return "Comma"; + case Key::VKFW_ENUMERATOR(Minus): + return "Minus"; + case Key::VKFW_ENUMERATOR(Period): + return "Period"; + case Key::VKFW_ENUMERATOR(Slash): + return "Slash"; + case Key::VKFW_ENUMERATOR2(0, _0): + return "0"; + case Key::VKFW_ENUMERATOR2(1, _1): + return "1"; + case Key::VKFW_ENUMERATOR2(2, _2): + return "2"; + case Key::VKFW_ENUMERATOR2(3, _3): + return "3"; + case Key::VKFW_ENUMERATOR2(4, _4): + return "4"; + case Key::VKFW_ENUMERATOR2(5, _5): + return "5"; + case Key::VKFW_ENUMERATOR2(6, _6): + return "6"; + case Key::VKFW_ENUMERATOR2(7, _7): + return "7"; + case Key::VKFW_ENUMERATOR2(8, _8): + return "8"; + case Key::VKFW_ENUMERATOR2(9, _9): + return "9"; + case Key::VKFW_ENUMERATOR(Semicolon): + return "Semicolon"; + case Key::VKFW_ENUMERATOR(Equal): + return "Equal"; + case Key::VKFW_ENUMERATOR(A): + return "A"; + case Key::VKFW_ENUMERATOR(B): + return "B"; + case Key::VKFW_ENUMERATOR(C): + return "C"; + case Key::VKFW_ENUMERATOR(D): + return "D"; + case Key::VKFW_ENUMERATOR(E): + return "E"; + case Key::VKFW_ENUMERATOR(F): + return "F"; + case Key::VKFW_ENUMERATOR(G): + return "G"; + case Key::VKFW_ENUMERATOR(H): + return "H"; + case Key::VKFW_ENUMERATOR(I): + return "I"; + case Key::VKFW_ENUMERATOR(J): + return "J"; + case Key::VKFW_ENUMERATOR(K): + return "K"; + case Key::VKFW_ENUMERATOR(L): + return "L"; + case Key::VKFW_ENUMERATOR(M): + return "M"; + case Key::VKFW_ENUMERATOR(N): + return "N"; + case Key::VKFW_ENUMERATOR(O): + return "O"; + case Key::VKFW_ENUMERATOR(P): + return "P"; + case Key::VKFW_ENUMERATOR(Q): + return "Q"; + case Key::VKFW_ENUMERATOR(R): + return "R"; + case Key::VKFW_ENUMERATOR(S): + return "S"; + case Key::VKFW_ENUMERATOR(T): + return "T"; + case Key::VKFW_ENUMERATOR(U): + return "U"; + case Key::VKFW_ENUMERATOR(V): + return "V"; + case Key::VKFW_ENUMERATOR(W): + return "W"; + case Key::VKFW_ENUMERATOR(X): + return "X"; + case Key::VKFW_ENUMERATOR(Y): + return "Y"; + case Key::VKFW_ENUMERATOR(Z): + return "Z"; + case Key::VKFW_ENUMERATOR(LeftBracket): + return "LeftBracket"; + case Key::VKFW_ENUMERATOR(Backslash): + return "Backslash"; + case Key::VKFW_ENUMERATOR(RightBracket): + return "RightBracket"; + case Key::VKFW_ENUMERATOR(GraveAccent): + return "GraveAccent"; + case Key::VKFW_ENUMERATOR(World1): + return "World1"; + case Key::VKFW_ENUMERATOR(World2): + return "World2"; + + /* + * Function Keys + */ + case Key::VKFW_ENUMERATOR(Escape): + return "Escape"; + case Key::VKFW_ENUMERATOR(Enter): + return "Enter"; + case Key::VKFW_ENUMERATOR(Tab): + return "Tab"; + case Key::VKFW_ENUMERATOR(Backspace): + return "Backspace"; + case Key::VKFW_ENUMERATOR(Insert): + return "Insert"; + case Key::VKFW_ENUMERATOR(Delete): + return "Delete"; + case Key::VKFW_ENUMERATOR(Right): + return "Right"; + case Key::VKFW_ENUMERATOR(Left): + return "Left"; + case Key::VKFW_ENUMERATOR(Down): + return "Down"; + case Key::VKFW_ENUMERATOR(Up): + return "Up"; + case Key::VKFW_ENUMERATOR(PageUp): + return "PageUp"; + case Key::VKFW_ENUMERATOR(PageDown): + return "PageDown"; + case Key::VKFW_ENUMERATOR(Home): + return "Home"; + case Key::VKFW_ENUMERATOR(End): + return "End"; + case Key::VKFW_ENUMERATOR(CapsLock): + return "CapsLock"; + case Key::VKFW_ENUMERATOR(ScrollLock): + return "ScrollLock"; + case Key::VKFW_ENUMERATOR(NumLock): + return "NumLock"; + case Key::VKFW_ENUMERATOR(PrintScreen): + return "PrintScreen"; + case Key::VKFW_ENUMERATOR(Pause): + return "Pause"; + case Key::VKFW_ENUMERATOR(F1): + return "F1"; + case Key::VKFW_ENUMERATOR(F2): + return "F2"; + case Key::VKFW_ENUMERATOR(F3): + return "F3"; + case Key::VKFW_ENUMERATOR(F4): + return "F4"; + case Key::VKFW_ENUMERATOR(F5): + return "F5"; + case Key::VKFW_ENUMERATOR(F6): + return "F6"; + case Key::VKFW_ENUMERATOR(F7): + return "F7"; + case Key::VKFW_ENUMERATOR(F8): + return "F8"; + case Key::VKFW_ENUMERATOR(F9): + return "F9"; + case Key::VKFW_ENUMERATOR(F10): + return "F10"; + case Key::VKFW_ENUMERATOR(F11): + return "F11"; + case Key::VKFW_ENUMERATOR(F12): + return "F12"; + case Key::VKFW_ENUMERATOR(F13): + return "F13"; + case Key::VKFW_ENUMERATOR(F14): + return "F14"; + case Key::VKFW_ENUMERATOR(F15): + return "F15"; + case Key::VKFW_ENUMERATOR(F16): + return "F16"; + case Key::VKFW_ENUMERATOR(F17): + return "F17"; + case Key::VKFW_ENUMERATOR(F18): + return "F18"; + case Key::VKFW_ENUMERATOR(F19): + return "F19"; + case Key::VKFW_ENUMERATOR(F20): + return "F20"; + case Key::VKFW_ENUMERATOR(F21): + return "F21"; + case Key::VKFW_ENUMERATOR(F22): + return "F22"; + case Key::VKFW_ENUMERATOR(F23): + return "F23"; + case Key::VKFW_ENUMERATOR(F24): + return "F24"; + case Key::VKFW_ENUMERATOR(F25): + return "F25"; + case Key::VKFW_ENUMERATOR(KeyPad_0): + return "KeyPad 0"; + case Key::VKFW_ENUMERATOR(KeyPad_1): + return "KeyPad 1"; + case Key::VKFW_ENUMERATOR(KeyPad_2): + return "KeyPad 2"; + case Key::VKFW_ENUMERATOR(KeyPad_3): + return "KeyPad 3"; + case Key::VKFW_ENUMERATOR(KeyPad_4): + return "KeyPad 4"; + case Key::VKFW_ENUMERATOR(KeyPad_5): + return "KeyPad 5"; + case Key::VKFW_ENUMERATOR(KeyPad_6): + return "KeyPad 6"; + case Key::VKFW_ENUMERATOR(KeyPad_7): + return "KeyPad 7"; + case Key::VKFW_ENUMERATOR(KeyPad_8): + return "KeyPad 8"; + case Key::VKFW_ENUMERATOR(KeyPad_9): + return "KeyPad 9"; + case Key::VKFW_ENUMERATOR(KeyPad_Decimal): + return "KeyPad Decimal"; + case Key::VKFW_ENUMERATOR(KeyPad_Divide): + return "KeyPad Divide"; + case Key::VKFW_ENUMERATOR(KeyPad_Multiply): + return "KeyPad Multiply"; + case Key::VKFW_ENUMERATOR(KeyPad_Subtract): + return "KeyPad Subtract"; + case Key::VKFW_ENUMERATOR(KeyPad_Add): + return "KeyPad Add"; + case Key::VKFW_ENUMERATOR(KeyPad_Enter): + return "KeyPad Enter"; + case Key::VKFW_ENUMERATOR(KeyPad_Equal): + return "KeyPad Equal"; + case Key::VKFW_ENUMERATOR(LeftShift): + return "LeftShift"; + case Key::VKFW_ENUMERATOR(LeftControl): + return "LeftControl"; + case Key::VKFW_ENUMERATOR(LeftAlt): + return "LeftAlt"; + case Key::VKFW_ENUMERATOR(LeftSuper): + return "LeftSuper"; + case Key::VKFW_ENUMERATOR(RightShift): + return "RightShift"; + case Key::VKFW_ENUMERATOR(RightControl): + return "RightControl"; + case Key::VKFW_ENUMERATOR(RightAlt): + return "RightAlt"; + case Key::VKFW_ENUMERATOR(RightSuper): + return "RightSuper"; + case Key::VKFW_ENUMERATOR(Menu): + return "Menu"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(MouseButton value) { + switch (value) { + case MouseButton::VKFW_ENUMERATOR2(1, _1): + return "1 (left)"; + case MouseButton::VKFW_ENUMERATOR2(2, _2): + return "2 (right)"; + case MouseButton::VKFW_ENUMERATOR2(3, _3): + return "3 (middle)"; + case MouseButton::VKFW_ENUMERATOR2(4, _4): + return "4"; + case MouseButton::VKFW_ENUMERATOR2(5, _5): + return "5"; + case MouseButton::VKFW_ENUMERATOR2(6, _6): + return "6"; + case MouseButton::VKFW_ENUMERATOR2(7, _7): + return "7"; + case MouseButton::VKFW_ENUMERATOR2(8, _8): + return "8"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(Joystick value) { + switch (value) { + case Joystick::VKFW_ENUMERATOR2(1, _1): + return "1"; + case Joystick::VKFW_ENUMERATOR2(2, _2): + return "2"; + case Joystick::VKFW_ENUMERATOR2(3, _3): + return "3"; + case Joystick::VKFW_ENUMERATOR2(4, _4): + return "4"; + case Joystick::VKFW_ENUMERATOR2(5, _5): + return "5"; + case Joystick::VKFW_ENUMERATOR2(6, _6): + return "6"; + case Joystick::VKFW_ENUMERATOR2(7, _7): + return "7"; + case Joystick::VKFW_ENUMERATOR2(8, _8): + return "8"; + case Joystick::VKFW_ENUMERATOR2(9, _9): + return "9"; + case Joystick::VKFW_ENUMERATOR2(10, _10): + return "10"; + case Joystick::VKFW_ENUMERATOR2(11, _11): + return "11"; + case Joystick::VKFW_ENUMERATOR2(12, _12): + return "12"; + case Joystick::VKFW_ENUMERATOR2(13, _13): + return "13"; + case Joystick::VKFW_ENUMERATOR2(14, _14): + return "14"; + case Joystick::VKFW_ENUMERATOR2(15, _15): + return "15"; + case Joystick::VKFW_ENUMERATOR2(16, _16): + return "16"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(GamepadButton value) { + switch (value) { + case GamepadButton::VKFW_ENUMERATOR(A): + return "A (Cross)"; + case GamepadButton::VKFW_ENUMERATOR(B): + return "B (Circle)"; + case GamepadButton::VKFW_ENUMERATOR(X): + return "X (Square)"; + case GamepadButton::VKFW_ENUMERATOR(Y): + return "Y (Triangle)"; + case GamepadButton::VKFW_ENUMERATOR(LeftBumper): + return "Left Bumper"; + case GamepadButton::VKFW_ENUMERATOR(RightBumper): + return "Right Bumper"; + case GamepadButton::VKFW_ENUMERATOR(Back): + return "Back"; + case GamepadButton::VKFW_ENUMERATOR(Start): + return "Start"; + case GamepadButton::VKFW_ENUMERATOR(Guide): + return "Guide"; + case GamepadButton::VKFW_ENUMERATOR(LeftThumb): + return "Left Thumb"; + case GamepadButton::VKFW_ENUMERATOR(RightThumb): + return "Right Thumb"; + case GamepadButton::VKFW_ENUMERATOR(DpadUp): + return "Dpad Up"; + case GamepadButton::VKFW_ENUMERATOR(DpadRight): + return "Dpad Right"; + case GamepadButton::VKFW_ENUMERATOR(DpadDown): + return "Dpad Down"; + case GamepadButton::VKFW_ENUMERATOR(DpadLeft): + return "Dpad Left"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(GamepadAxis value) { + switch (value) { + case GamepadAxis::VKFW_ENUMERATOR(LeftX): + return "Left X"; + case GamepadAxis::VKFW_ENUMERATOR(LeftY): + return "Left Y"; + case GamepadAxis::VKFW_ENUMERATOR(RightX): + return "Right X"; + case GamepadAxis::VKFW_ENUMERATOR(RightY): + return "Right Y"; + case GamepadAxis::VKFW_ENUMERATOR(LeftTrigger): + return "Left Trigger"; + case GamepadAxis::VKFW_ENUMERATOR(RightTrigger): + return "Right Trigger"; + default: + return "invalid"; + } + } + VKFW_INLINE std::string to_string(Result value) { + switch (value) { + case Result::VKFW_ENUMERATOR(Success): + return "No error has occurred"; + case Result::VKFW_ENUMERATOR(NotInitialized): + return "GLFW has not been initialized"; + case Result::VKFW_ENUMERATOR(NoCurrentContext): + return "No context is current for this thread"; + case Result::VKFW_ENUMERATOR(InvalidEnum): + return "One of the arguments to the function was an invalid enum value"; + case Result::VKFW_ENUMERATOR(InvalidValue): + return "One of the arguments to the function was an invalid value"; + case Result::VKFW_ENUMERATOR(OutOfMemory): + return "A memory allocation failed"; + case Result::VKFW_ENUMERATOR(ApiUnavailable): + return "GLFW could not find support for the requested API on the system"; + case Result::VKFW_ENUMERATOR(VersionUnavailable): + return "The requested OpenGL or OpenGL ES version is not available"; + case Result::VKFW_ENUMERATOR(PlatformError): + return "A platform-specific error occurred that does not match " + "any of the more specific categories"; + case Result::VKFW_ENUMERATOR(FormatUnavailable): + return "The requested format is not supported or available"; + case Result::VKFW_ENUMERATOR(NoWindowContext): + return "The specified window does not have an OpenGL or OpenGL ES context"; + case Result::VKFW_ENUMERATOR(CursorUnavailable): + return "The specified cursor shape is not available."; + case Result::VKFW_ENUMERATOR(FeatureUnavailable): + return "The requested feature is not provided by the platform."; + case Result::VKFW_ENUMERATOR(FeatureUnimplemented): + return "The requested feature is not implemented for the platform."; + case Result::VKFW_ENUMERATOR(PlatformUnavailable): + return "Platform unavailable or no matching platform was found."; + default: + return "invalid"; + } + } + + VKFW_INLINE std::string to_string(ModifierKeyFlags value) { + if (!value) + return "{}"; + std::string output; + + if (value & ModifierKeyBits::VKFW_ENUMERATOR(CapsLock)) + output += "CapsLock | "; + if (value & ModifierKeyBits::VKFW_ENUMERATOR(NumLock)) + output += "NumLock | "; + + if (value & ModifierKeyBits::VKFW_ENUMERATOR(Control)) + output += "Control + "; + if (value & ModifierKeyBits::VKFW_ENUMERATOR(Alt)) + output += "Alt + "; + if (value & ModifierKeyBits::VKFW_ENUMERATOR(Super)) + output += "Super + "; + + return "{ " + output.substr(0, output.size() - 3) + " }"; + } + +#ifndef VKFW_NO_ENHANCED_MODE + template + struct InitializationHintTraits; + template <> + struct InitializationHintTraits { + using type = Platform; + }; + template <> + struct InitializationHintTraits { + using type = AnglePlatformType; + }; + template <> + struct InitializationHintTraits { + using type = bool; + }; + template <> + struct InitializationHintTraits { + using type = bool; + }; + template <> + struct InitializationHintTraits { + using type = bool; + }; + template <> + struct InitializationHintTraits { + using type = WaylandLibDecor; + }; + template <> + struct InitializationHintTraits { + using type = bool; + }; + + template + struct WindowHintTraits; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = ClientAPI; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = unsigned; + }; + template <> + struct WindowHintTraits { + using type = ContextRobustness; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = OpenGLProfile; + }; + template <> + struct WindowHintTraits { + using type = ContextReleaseBehavior; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = ContextCreationAPI; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { +#ifdef VKFW_HAS_STRING_VIEW + using type = std::string_view; +#else + using type = char const*; +#endif + }; + template <> + struct WindowHintTraits { + using type = bool; + }; + template <> + struct WindowHintTraits { +#ifdef VKFW_HAS_STRING_VIEW + using type = std::string_view; +#else + using type = char const*; +#endif + }; + template <> + struct WindowHintTraits { +#ifdef VKFW_HAS_STRING_VIEW + using type = std::string_view; +#else + using type = char const*; +#endif + }; + template <> + struct WindowHintTraits { +#ifdef VKFW_HAS_STRING_VIEW + using type = std::string_view; +#else + using type = char const*; +#endif + }; + + template + struct AttributeTraits; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::true_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::true_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::true_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::true_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::true_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::true_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = ClientAPI; + }; + template <> + struct AttributeTraits : std::false_type { + using type = size_t; + }; + template <> + struct AttributeTraits : std::false_type { + using type = size_t; + }; + template <> + struct AttributeTraits : std::false_type { + using type = size_t; + }; + template <> + struct AttributeTraits : std::false_type { + using type = ContextRobustness; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = OpenGLProfile; + }; + template <> + struct AttributeTraits : std::false_type { + using type = ContextReleaseBehavior; + }; + template <> + struct AttributeTraits : std::false_type { + using type = bool; + }; + template <> + struct AttributeTraits : std::false_type { + using type = ContextCreationAPI; + }; + + template + struct InputModeTraits; + template <> + struct InputModeTraits { + using type = CursorMode; + }; + template <> + struct InputModeTraits { + using type = bool; + }; + template <> + struct InputModeTraits { + using type = bool; + }; + template <> + struct InputModeTraits { + using type = bool; + }; + template <> + struct InputModeTraits { + using type = bool; + }; +#endif +} // namespace VKFW_NAMESPACE + +namespace VKFW_NAMESPACE { +#ifndef VKFW_NO_SMART_HANDLE +#ifndef VKFW_NO_INCLUDE_VULKAN_HPP + template + using UniqueHandleTraits = + VULKAN_HPP_NAMESPACE::UniqueHandleTraits; + template + using UniqueHandle = VULKAN_HPP_NAMESPACE::UniqueHandle; +#else + template + class UniqueHandleTraits; + template + class UniqueHandle : public UniqueHandleTraits::deleter { + private: + using Deleter = typename UniqueHandleTraits::deleter; + + public: + using element_type = Type; + + UniqueHandle() : Deleter(), m_value() {} + explicit UniqueHandle(Type const& value, Deleter const& deleter = Deleter()) VKFW_NOEXCEPT + : Deleter(deleter), + m_value(value) {} + UniqueHandle(UniqueHandle const&) = delete; + UniqueHandle(UniqueHandle&& other) VKFW_NOEXCEPT : Deleter(std::move(static_cast(other))), + m_value(other.release()) {} + ~UniqueHandle() VKFW_NOEXCEPT { + if (m_value) + this->destroy(m_value); + } + + UniqueHandle& operator=(UniqueHandle const&) = delete; + UniqueHandle& operator=(UniqueHandle&& other) VKFW_NOEXCEPT { + reset(other.release()); + *static_cast(this) = std::move(static_cast(other)); + return *this; + } + + explicit operator bool() const VKFW_NOEXCEPT { return m_value.operator bool(); } + Type const* operator->() const VKFW_NOEXCEPT { return &m_value; } + Type* operator->() VKFW_NOEXCEPT { return &m_value; } + Type const& operator*() const VKFW_NOEXCEPT { return m_value; } + Type& operator*() VKFW_NOEXCEPT { return m_value; } + const Type& get() const VKFW_NOEXCEPT { return m_value; } + Type& get() VKFW_NOEXCEPT { return m_value; } + void reset(Type const& value = Type()) VKFW_NOEXCEPT { + if (m_value != value) { + if (m_value) + this->destroy(m_value); + m_value = value; + } + } + Type release() VKFW_NOEXCEPT { + Type value = m_value; + m_value = nullptr; + return value; + } + void swap(UniqueHandle& rhs) VKFW_NOEXCEPT { + std::swap(m_value, rhs.m_value); + std::swap(static_cast(*this), static_cast(rhs)); + } + + private: + Type m_value; + }; +#endif +#endif +} // namespace VKFW_NAMESPACE + +#ifndef VKFW_NO_EXCEPTIONS +namespace std { + template <> + struct is_error_code_enum : public true_type {}; +} // namespace std +#endif + +namespace VKFW_NAMESPACE { +#ifndef VKFW_NO_EXCEPTIONS + class ErrorCategoryImpl : public std::error_category { + public: + virtual char const* name() const VKFW_NOEXCEPT override { return VKFW_NAMESPACE_STRING "::Result"; } + virtual std::string message(int ev) const override { return to_string(static_cast(ev)); } + }; + class Error { + public: + Error() VKFW_NOEXCEPT = default; + Error(const Error&) VKFW_NOEXCEPT = default; + virtual ~Error() VKFW_NOEXCEPT = default; + + virtual char const* what() const VKFW_NOEXCEPT = 0; + }; + class SystemError : public Error, public std::system_error { + public: + SystemError(std::error_code ec) : Error(), std::system_error(ec) {} + SystemError(std::error_code ec, std::string const& what) : Error(), std::system_error(ec, what) {} + SystemError(std::error_code ec, char const* what) : Error(), std::system_error(ec, what) {} + SystemError(int ev, std::error_category const& ecat) : Error(), std::system_error(ev, ecat) {} + SystemError(int ev, std::error_category const& ecat, std::string const& what) + : Error(), std::system_error(ev, ecat, what) {} + SystemError(int ev, std::error_category const& ecat, char const* what) + : Error(), std::system_error(ev, ecat, what) {} + + virtual char const* what() const VKFW_NOEXCEPT { return std::system_error::what(); } + }; + VKFW_INLINE const std::error_category& errorCategory() VKFW_NOEXCEPT { + static ErrorCategoryImpl instance; + return instance; + } + VKFW_INLINE std::error_code make_error_code(Result e) VKFW_NOEXCEPT { + return std::error_code(static_cast(e), errorCategory()); + } + VKFW_INLINE std::error_condition make_error_condition(Result e) VKFW_NOEXCEPT { + return std::error_condition(static_cast(e), errorCategory()); + } + class NotInitializedError : public SystemError { + public: + NotInitializedError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(NotInitialized)), message) {} + NotInitializedError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(NotInitialized)), message) {} + }; + class NoCurrentContextError : public SystemError { + public: + NoCurrentContextError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(NoCurrentContext)), message) {} + NoCurrentContextError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(NoCurrentContext)), message) {} + }; + class InvalidEnumError : public SystemError { + public: + InvalidEnumError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(InvalidEnum)), message) {} + InvalidEnumError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(InvalidEnum)), message) {} + }; + class InvalidValueError : public SystemError { + public: + InvalidValueError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(InvalidValue)), message) {} + InvalidValueError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(InvalidValue)), message) {} + }; + class OutOfMemoryError : public SystemError { + public: + OutOfMemoryError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(OutOfMemory)), message) {} + OutOfMemoryError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(OutOfMemory)), message) {} + }; + class ApiUnavailableError : public SystemError { + public: + ApiUnavailableError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(ApiUnavailable)), message) {} + ApiUnavailableError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(ApiUnavailable)), message) {} + }; + class VersionUnavailableError : public SystemError { + public: + VersionUnavailableError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(VersionUnavailable)), message) {} + VersionUnavailableError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(VersionUnavailable)), message) {} + }; + class PlatformError : public SystemError { + public: + PlatformError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(PlatformError)), message) {} + PlatformError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(PlatformError)), message) {} + }; + class FormatUnavailableError : public SystemError { + public: + FormatUnavailableError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(FormatUnavailable)), message) {} + FormatUnavailableError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(FormatUnavailable)), message) {} + }; + class NoWindowContextError : public SystemError { + public: + NoWindowContextError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(NoWindowContext)), message) {} + NoWindowContextError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(NoWindowContext)), message) {} + }; + class CursorUnavailableError : public SystemError { + public: + CursorUnavailableError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(CursorUnavailable)), message) {} + CursorUnavailableError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(CursorUnavailable)), message) {} + }; + class FeatureUnavailableError : public SystemError { + public: + FeatureUnavailableError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(FeatureUnavailable)), message) {} + FeatureUnavailableError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(FeatureUnavailable)), message) {} + }; + class FeatureUnimplementedError : public SystemError { + public: + FeatureUnimplementedError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(FeatureUnimplemented)), message) {} + FeatureUnimplementedError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(FeatureUnimplemented)), message) {} + }; + class PlatformUnavailableError : public SystemError { + public: + PlatformUnavailableError(std::string const& message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(PlatformUnavailable)), message) {} + PlatformUnavailableError(char const* message) + : SystemError(make_error_code(Result::VKFW_ENUMERATOR(PlatformUnavailable)), message) {} + }; + + [[noreturn]] static void throwResultException(Result result, char const* message) { + switch (result) { + // case Result::VKFW_ENUMERATOR(Success): break; + case Result::VKFW_ENUMERATOR(NotInitialized): + throw NotInitializedError(message); + case Result::VKFW_ENUMERATOR(NoCurrentContext): + throw NoCurrentContextError(message); + case Result::VKFW_ENUMERATOR(InvalidEnum): + throw InvalidEnumError(message); + case Result::VKFW_ENUMERATOR(InvalidValue): + throw InvalidValueError(message); + case Result::VKFW_ENUMERATOR(OutOfMemory): + throw OutOfMemoryError(message); + case Result::VKFW_ENUMERATOR(ApiUnavailable): + throw ApiUnavailableError(message); + case Result::VKFW_ENUMERATOR(VersionUnavailable): + throw VersionUnavailableError(message); + case Result::VKFW_ENUMERATOR(PlatformError): + throw PlatformError(message); + case Result::VKFW_ENUMERATOR(FormatUnavailable): + throw FormatUnavailableError(message); + case Result::VKFW_ENUMERATOR(NoWindowContext): + throw NoWindowContextError(message); + case Result::VKFW_ENUMERATOR(CursorUnavailable): + throw CursorUnavailableError(message); + case Result::VKFW_ENUMERATOR(FeatureUnavailable): + throw FeatureUnavailableError(message); + case Result::VKFW_ENUMERATOR(FeatureUnimplemented): + throw FeatureUnimplementedError(message); + case Result::VKFW_ENUMERATOR(PlatformUnavailable): + throw PlatformUnavailableError(message); + default: + throw SystemError(make_error_code(result)); + } + } +#endif + + template + struct ResultValue { +#ifdef VKFW_HAS_NOEXCEPT + ResultValue(Result r, T&& v) VKFW_NOEXCEPT(VKFW_NOEXCEPT(T(std::move(v)))) +#else + ResultValue(Result r, T&& v) +#endif + : result(r), value(std::move(v)) { + } + + Result result; + T value; + + operator std::tuple() VKFW_NOEXCEPT { return std::tuple(result, value); } + }; + +#ifndef VKFW_NO_SMART_HANDLE + template + struct ResultValue> { +#ifdef VKFW_HAS_NOEXCEPT + ResultValue(Result r, UniqueHandle&& v) VKFW_NOEXCEPT +#else + ResultValue(Result r, UniqueHandle&& v) +#endif + : result(r), + value(std::move(v)) { + } + + std::tuple> asTuple() { return std::make_tuple(result, std::move(value)); } + + Result result; + UniqueHandle value; + }; +#endif + + template + struct ResultValueType { +#ifdef VKFW_NO_EXCEPTIONS + typedef ResultValue type; +#else + typedef T type; +#endif + }; + template <> + struct ResultValueType { +#ifdef VKFW_NO_EXCEPTIONS + typedef Result type; +#else + typedef void type; +#endif + }; + + template + VKFW_INLINE void ignore(T const&) VKFW_NOEXCEPT {} + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + createResultValue(Result result, char const* message) { +#ifdef VKFW_NO_EXCEPTIONS + ignore(message); + VKFW_ASSERT_ON_RESULT(result == Result::VKFW_ENUMERATOR(Success)); + return result; +#else + if (!check(result)) + throwResultException(result, message); +#endif + } + template + VKFW_INLINE typename ResultValueType::type + createResultValue(Result result, T& data, char const* message) { +#ifdef VKFW_NO_EXCEPTIONS + ignore(message); + VKFW_ASSERT_ON_RESULT(result == Result::VKFW_ENUMERATOR(Success)); + return ResultValue(result, std::move(data)); +#else + if (!check(result)) + throwResultException(result, message); + return std::move(data); +#endif + } +#ifndef VKFW_NO_SMART_HANDLE + template + VKFW_INLINE typename ResultValueType>::type + createResultValueUnique(Result result, T& data, char const* message) { +#ifdef VKFW_NO_EXCEPTIONS + ignore(message); + VKFW_ASSERT_ON_RESULT(result == Result::VKFW_ENUMERATOR(Success)); + return ResultValue>(result, UniqueHandle(data)); +#else + if (!check(result)) + throwResultException(result, message); + return UniqueHandle(data); +#endif + } +#endif +#ifndef VKFW_NO_SMART_HANDLE + template + struct CustomDestroy { + void destroy(T&) { static_assert("Cannot delete an object without a specified deleter."); } + }; +#endif +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS + struct DynamicCallbackStorage; +#endif + + struct Nullopt {}; + VKFW_CONSTEXPR Nullopt nullopt = {}; + template + class Optional { + public: + using value_type = T; + + VKFW_INLINE VKFW_CONSTEXPR Optional() : m_has_value(false) {} + VKFW_INLINE VKFW_CONSTEXPR Optional(Nullopt) : m_has_value(false) {} + VKFW_INLINE VKFW_CONSTEXPR Optional(value_type const& value) : m_has_value(true), m_value(value) {} + VKFW_INLINE VKFW_CONSTEXPR Optional(value_type&& value) : m_has_value(true), m_value(std::move(value)) {} + template < + typename convertible_value_type, + typename = + typename std::enable_if::value>::type> + VKFW_INLINE VKFW_CONSTEXPR Optional(convertible_value_type const& value) + : m_has_value(true), m_value(value_type { value }) {} + template < + typename convertible_value_type, + typename = + typename std::enable_if::value>::type> + VKFW_INLINE VKFW_CONSTEXPR Optional(convertible_value_type&& value) + : m_has_value(true), m_value(value_type { std::move(value) }) {} + template + VKFW_INLINE VKFW_CONSTEXPR Optional(Optional const& another) + : m_has_value(another.m_has_value), m_value(another.m_value) {} + template + VKFW_INLINE VKFW_CONSTEXPR Optional(Optional&& another) + : m_has_value(another.m_has_value), m_value(std::move(another.m_value)) {} + VKFW_INLINE VKFW_CONSTEXPR Optional& operator=(Nullopt) { + m_has_value = false; + return *this; + } + template + VKFW_INLINE VKFW_CONSTEXPR_14 Optional& operator=(Optional const& another) { + m_has_value = another.m_has_value; + m_value = another.m_value; + return *this; + } + template + VKFW_INLINE VKFW_CONSTEXPR_14 Optional& operator=(Optional&& another) { + m_has_value = another.m_has_value; + m_value = std::move(another.m_value); + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR bool has_value() const { return m_has_value; } + VKFW_INLINE VKFW_CONSTEXPR_14 value_type const& value() const { + assert(m_has_value); + return m_value; + } + + private: + bool m_has_value; + T m_value; + }; + +#ifndef VKFW_DISABLE_ENHANCED_MODE + class Instance { + public: + using CType = void; + VKFW_INLINE VKFW_CONSTEXPR Instance() : m_state(false) {} + VKFW_INLINE VKFW_CONSTEXPR Instance(std::nullptr_t) VKFW_NOEXCEPT : m_state(false) {} + VKFW_INLINE VKFW_CONSTEXPR Instance(bool state) VKFW_NOEXCEPT : m_state(state) {} + VKFW_INLINE VKFW_CONSTEXPR Instance(Instance const& another) VKFW_NOEXCEPT : m_state(another.m_state) {} + VKFW_INLINE VKFW_CONSTEXPR_14 Instance(Instance&& another) VKFW_NOEXCEPT : m_state(another.m_state) { + another.m_state = false; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Instance operator=(Instance const& another) VKFW_NOEXCEPT { + m_state = another.m_state; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Instance operator=(Instance&& another) VKFW_NOEXCEPT { + m_state = another.m_state; + another.m_state = false; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Instance& operator=(bool state) VKFW_NOEXCEPT { + m_state = state; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Instance& operator=(std::nullptr_t) VKFW_NOEXCEPT { + m_state = false; + return *this; + } + VKFW_INLINE explicit operator bool() const VKFW_NOEXCEPT { return m_state; } + VKFW_INLINE bool operator!() const VKFW_NOEXCEPT { return !m_state; } +#if defined(VKFW_HAS_SPACESHIP_OPERATOR) + auto operator<=>(Instance const&) const = default; +#else + bool operator==(Instance const& another) const VKFW_NOEXCEPT { return m_state == another.m_state; } + bool operator!=(Instance const& another) const VKFW_NOEXCEPT { return !operator==(another); } +#endif + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type destroy(); + + private: + bool m_state; + }; + + class Monitor { + public: + using CType = GLFWmonitor; + + public: + VKFW_INLINE VKFW_CONSTEXPR Monitor() VKFW_NOEXCEPT : m_monitor(nullptr) {} + VKFW_INLINE VKFW_CONSTEXPR Monitor(std::nullptr_t) VKFW_NOEXCEPT : m_monitor(nullptr) {} + VKFW_INLINE VKFW_CONSTEXPR Monitor(GLFWmonitor* monitor) VKFW_NOEXCEPT : m_monitor(monitor) {} + VKFW_INLINE VKFW_CONSTEXPR Monitor(Monitor const& another) VKFW_NOEXCEPT : m_monitor(another.m_monitor) {} + VKFW_INLINE VKFW_CONSTEXPR_14 Monitor(Monitor&& another) VKFW_NOEXCEPT : m_monitor(another.m_monitor) { + another.m_monitor = nullptr; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Monitor operator=(Monitor const& another) VKFW_NOEXCEPT { + m_monitor = another.m_monitor; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Monitor operator=(Monitor&& another) VKFW_NOEXCEPT { + m_monitor = another.m_monitor; + another.m_monitor = nullptr; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Monitor& operator=(GLFWmonitor* monitor) VKFW_NOEXCEPT { + m_monitor = monitor; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Monitor& operator=(std::nullptr_t) VKFW_NOEXCEPT { + m_monitor = nullptr; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR operator GLFWmonitor*() const VKFW_NOEXCEPT { return m_monitor; } + VKFW_INLINE VKFW_CONSTEXPR explicit operator bool() const VKFW_NOEXCEPT { return m_monitor != nullptr; } + VKFW_INLINE VKFW_CONSTEXPR bool operator!() const VKFW_NOEXCEPT { return m_monitor == nullptr; } +#if defined(VKFW_HAS_SPACESHIP_OPERATOR) + auto operator<=>(Monitor const&) const = default; +#else + bool operator==(Monitor const& another) const VKFW_NOEXCEPT { return m_monitor == another.m_monitor; } + bool operator!=(Monitor const& another) const VKFW_NOEXCEPT { return !operator==(another); } +#endif + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type getPos(int* xpos, int* ypos) const; + VKFW_NODISCARD typename ResultValueType>::type getPos() const; + VKFW_NODISCARD typename ResultValueType::type getPosX() const; + VKFW_NODISCARD typename ResultValueType::type getPosY() const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getWorkarea(int* xpos, int* ypos, size_t* width, size_t* height) const; + VKFW_NODISCARD typename ResultValueType>::type getWorkarea() const; + VKFW_NODISCARD typename ResultValueType>::type getWorkareaPos() const; + VKFW_NODISCARD typename ResultValueType::type getWorkareaPosX() const; + VKFW_NODISCARD typename ResultValueType::type getWorkareaPosY() const; + VKFW_NODISCARD typename ResultValueType>::type getWorkareaSize() const; + VKFW_NODISCARD typename ResultValueType::type getWorkareaWidth() const; + VKFW_NODISCARD typename ResultValueType::type getWorkareaHeight() const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getPhysicalSize(size_t* widthMM, size_t* heightMM) const; + VKFW_NODISCARD typename ResultValueType>::type getPhysicalSize() const; + VKFW_NODISCARD typename ResultValueType::type getPhysicalWidth() const; + VKFW_NODISCARD typename ResultValueType::type getPhysicalHeight() const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getContentScale(float* xscale, float* yscale) const; + VKFW_NODISCARD typename ResultValueType>::type getContentScale() const; + VKFW_NODISCARD typename ResultValueType::type getContentScaleX() const; + VKFW_NODISCARD typename ResultValueType::type getContentScaleY() const; + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD typename ResultValueType::type getName() const; +#else + VKFW_NODISCARD typename ResultValueType::type getName() const; +#endif + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setUserPointer(void* pointer + ) const; + VKFW_NODISCARD typename ResultValueType::type getUserPointer() const; + + VKFW_NODISCARD typename ResultValueType::type getVideoMode() const; +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD typename ResultValueType>::type getVideoModes() const; +#else + VKFW_NODISCARD typename ResultValueType>::type getVideoModes() const; +#endif + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setGamma(float gamma) const; + VKFW_NODISCARD typename ResultValueType::type getGammaRamp() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setGammaRamp( + GLFWgammaramp const* ramp + ) const; + + private: + GLFWmonitor* m_monitor; + }; + + class Cursor { + public: + using CType = GLFWcursor; + + public: + VKFW_INLINE VKFW_CONSTEXPR Cursor() VKFW_NOEXCEPT : m_cursor(nullptr) {} + VKFW_INLINE VKFW_CONSTEXPR Cursor(std::nullptr_t) VKFW_NOEXCEPT : m_cursor(nullptr) {} + VKFW_INLINE VKFW_CONSTEXPR Cursor(GLFWcursor* cursor) VKFW_NOEXCEPT : m_cursor(cursor) {} + VKFW_INLINE VKFW_CONSTEXPR Cursor(Cursor const& another) VKFW_NOEXCEPT : m_cursor(another.m_cursor) {} + VKFW_INLINE VKFW_CONSTEXPR_14 Cursor(Cursor&& another) VKFW_NOEXCEPT : m_cursor(another.m_cursor) { + another.m_cursor = nullptr; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Cursor operator=(Cursor const& another) VKFW_NOEXCEPT { + m_cursor = another.m_cursor; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Cursor operator=(Cursor&& another) VKFW_NOEXCEPT { + m_cursor = another.m_cursor; + another.m_cursor = nullptr; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Cursor& operator=(GLFWcursor* cursor) VKFW_NOEXCEPT { + m_cursor = cursor; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Cursor& operator=(std::nullptr_t) VKFW_NOEXCEPT { + m_cursor = nullptr; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR operator GLFWcursor*() const VKFW_NOEXCEPT { return m_cursor; } + VKFW_INLINE VKFW_CONSTEXPR explicit operator bool() const VKFW_NOEXCEPT { return m_cursor != nullptr; } + VKFW_INLINE VKFW_CONSTEXPR bool operator!() const VKFW_NOEXCEPT { return m_cursor == nullptr; } +#if defined(VKFW_HAS_SPACESHIP_OPERATOR) + auto operator<=>(Cursor const&) const = default; +#else + bool operator==(Cursor const& another) const VKFW_NOEXCEPT { return m_cursor == another.m_cursor; } + bool operator!=(Cursor const& another) const VKFW_NOEXCEPT { return !operator==(another); } +#endif + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type destroy(); + + private: + GLFWcursor* m_cursor; + }; + + using Image = GLFWimage; + + class Window { + public: + using CType = GLFWwindow; + + public: + VKFW_INLINE VKFW_CONSTEXPR Window() VKFW_NOEXCEPT : m_window(nullptr) {} + VKFW_INLINE VKFW_CONSTEXPR Window(std::nullptr_t) VKFW_NOEXCEPT : m_window(nullptr) {} + VKFW_INLINE VKFW_CONSTEXPR Window(GLFWwindow* window) VKFW_NOEXCEPT : m_window(window) {} + VKFW_INLINE VKFW_CONSTEXPR Window(Window const& another) VKFW_NOEXCEPT : m_window(another.m_window) {} + VKFW_INLINE VKFW_CONSTEXPR_14 Window(Window&& another) VKFW_NOEXCEPT : m_window(another.m_window) { + another.m_window = nullptr; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Window operator=(Window const& another) VKFW_NOEXCEPT { + m_window = another.m_window; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Window operator=(Window&& another) VKFW_NOEXCEPT { + m_window = another.m_window; + another.m_window = nullptr; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Window& operator=(GLFWwindow* window) VKFW_NOEXCEPT { + m_window = window; + return *this; + } + VKFW_INLINE VKFW_CONSTEXPR_14 Window& operator=(std::nullptr_t) VKFW_NOEXCEPT { + m_window = nullptr; + return *this; + } + + VKFW_INLINE VKFW_CONSTEXPR operator GLFWwindow*() const VKFW_NOEXCEPT { return m_window; } + VKFW_INLINE VKFW_CONSTEXPR explicit operator bool() const VKFW_NOEXCEPT { return m_window != nullptr; } + VKFW_INLINE VKFW_CONSTEXPR bool operator!() const VKFW_NOEXCEPT { return m_window == nullptr; } +#if defined(VKFW_HAS_SPACESHIP_OPERATOR) + auto operator<=>(Window const&) const = default; +#else + bool operator==(Window const& another) const VKFW_NOEXCEPT { return m_window == another.m_window; } + bool operator!=(Window const& another) const VKFW_NOEXCEPT { return !operator==(another); } +#endif + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type destroy(); + + VKFW_NODISCARD typename ResultValueType::type shouldClose() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setShouldClose(bool value) const; + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE std::string_view getTitle() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setTitle(std::string_view title + ) const; +#else + VKFW_NODISCARD VKFW_INLINE char const* getTitle() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setTitle(char const* title) const; +#endif + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type getPos(int* xpos, int* ypos) const; + VKFW_NODISCARD typename ResultValueType>::type getPos() const; + VKFW_NODISCARD typename ResultValueType::type getPosX() const; + VKFW_NODISCARD typename ResultValueType::type getPosY() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setPos(int xpos, int ypos) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setPos(std::tuple pos + ) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getSize(size_t* width, size_t* height) const; + VKFW_NODISCARD typename ResultValueType>::type getSize() const; + VKFW_NODISCARD typename ResultValueType::type getWidth() const; + VKFW_NODISCARD typename ResultValueType::type getHeight() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setSize(size_t width, size_t height) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setSize( + std::tuple size + ) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setSizeLimits( + size_t minimum_width, + size_t minimum_height, + size_t maximum_width, + size_t maximum_height + ) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setSizeLimits(std::tuple minimum_size, std::tuple maximum_size) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setSizeLimits( + std::tuple limits + ) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setAspectRatio(size_t numerator, size_t denominator) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getFramebufferSize(size_t* width, size_t* height) const; + VKFW_NODISCARD typename ResultValueType>::type getFramebufferSize() const; + VKFW_NODISCARD typename ResultValueType::type getFramebufferWidth() const; + VKFW_NODISCARD typename ResultValueType::type getFramebufferHeight() const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getFrameSize(size_t* left, size_t* top, size_t* right, size_t* bottom) const; + VKFW_NODISCARD typename ResultValueType>::type getFrameSize( + ) const; + VKFW_NODISCARD typename ResultValueType::type getLeftFrameSize() const; + VKFW_NODISCARD typename ResultValueType::type getTopFrameSize() const; + VKFW_NODISCARD typename ResultValueType::type getRightFrameSize() const; + VKFW_NODISCARD typename ResultValueType::type getBottomFrameSize() const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getContentScale(float* xscale, float* yscale) const; + VKFW_NODISCARD typename ResultValueType>::type getContentScale() const; + VKFW_NODISCARD typename ResultValueType::type getContentScaleX() const; + VKFW_NODISCARD typename ResultValueType::type getContentScaleY() const; + + VKFW_NODISCARD typename ResultValueType::type getOpacity() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setOpacity(float opacity) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type iconify() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type restore() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type maximize() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type show() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type hide() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type focus() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type requestAttention() const; + VKFW_NODISCARD typename ResultValueType::type getMonitor() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setMonitor( + Monitor const& monitor, + int xpos, + int ypos, + size_t width, + size_t height, + size_t refreshRate = 0 + ) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setMonitor( + Monitor const& monitor, + std::tuple pos, + std::tuple size, + size_t refreshRate = 0 + ) const; + +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setIcon( + std::span images + ) const; +#endif + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setIcon( + std::vector images + ) const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setIcon(size_t image_count, vkfw::Image* images) const; + + template + VKFW_NODISCARD typename ResultValueType::type>::type get() const; + + template < + Attribute attribute, + typename = typename std::enable_if::value>::type> + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type set( + typename AttributeTraits::type const& new_value + ) const; + + template + VKFW_NODISCARD typename ResultValueType::type>::type get() const; + + template + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type set( + typename InputModeTraits::type const& new_value + ) const; + +#ifdef VKFW_NO_STD_FUNCTION_CALLBACKS + VKFW_INLINE GLFWwindowposfun setPosCallback(GLFWwindowposfun callback) const { + return glfwSetWindowPosCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowsizefun setSizeCallback(GLFWwindowsizefun callback) const { + return glfwSetWindowSizeCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowclosefun setCloseCallback(GLFWwindowclosefun callback) const { + return glfwSetWindowCloseCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowrefreshfun setRefreshCallback(GLFWwindowrefreshfun callback) const { + return glfwSetWindowRefreshCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowfocusfun setFocusCallback(GLFWwindowfocusfun callback) const { + return glfwSetWindowFocusCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowiconifyfun setIconifyCallback(GLFWwindowiconifyfun callback) const { + return glfwSetWindowIconifyCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowmaximizefun setMaximizeCallback(GLFWwindowmaximizefun callback) const { + return glfwSetWindowMaximizeCallback(m_window, callback); + } + VKFW_INLINE GLFWframebuffersizefun setFramebufferSizeCallback(GLFWframebuffersizefun callback) const { + return glfwSetFramebufferSizeCallback(m_window, callback); + } + VKFW_INLINE GLFWwindowcontentscalefun setContentScaleCallback(GLFWwindowcontentscalefun callback) const { + return glfwSetWindowContentScaleCallback(m_window, callback); + } + VKFW_INLINE GLFWkeyfun setKeyCallback(GLFWkeyfun callback) const { + return glfwSetKeyCallback(m_window, callback); + } + VKFW_INLINE GLFWcharfun setCharCallback(GLFWcharfun callback) const { + return glfwSetCharCallback(m_window, callback); + } + VKFW_INLINE GLFWcharmodsfun setCharModsCallback(GLFWcharmodsfun callback) const { + return glfwSetCharModsCallback(m_window, callback); + } + VKFW_INLINE GLFWmousebuttonfun setMouseButtonCallback(GLFWmousebuttonfun callback) const { + return glfwSetMouseButtonCallback(m_window, callback); + } + VKFW_INLINE GLFWcursorposfun setCursorPosCallback(GLFWcursorposfun callback) const { + return glfwSetCursorPosCallback(m_window, callback); + } + VKFW_INLINE GLFWcursorenterfun setCursorEnterCallback(GLFWcursorenterfun callback) const { + return glfwSetCursorEnterCallback(m_window, callback); + } + VKFW_INLINE GLFWscrollfun setScrollCallback(GLFWscrollfun callback) const { + return glfwSetScrollCallback(m_window, callback); + } + VKFW_INLINE GLFWdropfun setDropCallback(GLFWdropfun callback) const { + return glfwSetDropCallback(m_window, callback); + } +#else + VKFW_NODISCARD VKFW_INLINE DynamicCallbackStorage* callbacks() const { + return reinterpret_cast(glfwGetWindowUserPointer(m_window)); + } +#endif + VKFW_NODISCARD typename ResultValueType::type getUserPointer() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setUserPointer(void* pointer + ) const; + + VKFW_NODISCARD typename ResultValueType::type getKey(Key key) const; + VKFW_NODISCARD typename ResultValueType::type getMouseButton(MouseButton button) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + getCursorPos(double* xpos, double* ypos) const; + VKFW_NODISCARD typename ResultValueType>::type getCursorPos() const; + VKFW_NODISCARD typename ResultValueType::type getCursorPosX() const; + VKFW_NODISCARD typename ResultValueType::type getCursorPosY() const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setCursorPos(double xpos, double ypos) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setCursor(Cursor const& cursor + ) const; + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type makeContextCurrent() const; + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type swapBuffers() const; + + private: + GLFWwindow* m_window; + }; +#endif + + VKFW_INLINE Result getError(char const** description = nullptr) { + return static_cast(glfwGetError(description)); + } + VKFW_INLINE GLFWerrorfun setErrorCallback(GLFWerrorfun callback) { return glfwSetErrorCallback(callback); } + + VKFW_NODISCARD VKFW_INLINE Platform getPlatform() { return static_cast(glfwGetPlatform()); } + VKFW_NODISCARD VKFW_INLINE bool platformSupported(Platform platform) { + return glfwPlatformSupported(static_cast(platform)) == GLFW_TRUE; + } + + template + VKFW_INLINE Result initHint(typename InitializationHintTraits::type value) { + glfwInitHint(static_cast(hint), static_cast(value)); + return getError(); + } +#ifndef VKFW_DISABLE_ENHANCED_MODE + template + class OptionalInitializationHint : public Optional::type> { + public: + using Optional::type>::Optional; + }; + struct InitHints { +#ifndef VKFW_NO_STRUCT_CONSTRUCTORS + public: + VKFW_CONSTEXPR InitHints( + OptionalInitializationHint platform_ = nullopt, + OptionalInitializationHint + joystickHatButtons_ = nullopt, + OptionalInitializationHint anglePlatformType_ = + nullopt, + OptionalInitializationHint + cocoaChdirResources_ = nullopt, + OptionalInitializationHint cocoaMenubar_ = nullopt, + OptionalInitializationHint waylandLibDecor_ = + nullopt, + OptionalInitializationHint + x11XCBVulkanSurface_ = nullopt + ) VKFW_NOEXCEPT : platform(platform_), + joystickHatButtons(joystickHatButtons_), + anglePlatformType(anglePlatformType_), + cocoaChdirResources(cocoaChdirResources_), + cocoaMenubar(cocoaMenubar_), + waylandLibDecor(waylandLibDecor_), + x11XCBVulkanSurface(x11XCBVulkanSurface_) {} +#endif + public: + OptionalInitializationHint platform = nullopt; + OptionalInitializationHint joystickHatButtons = + nullopt; + OptionalInitializationHint anglePlatformType = + nullopt; + OptionalInitializationHint cocoaChdirResources = + nullopt; + OptionalInitializationHint cocoaMenubar = nullopt; + OptionalInitializationHint waylandLibDecor = + nullopt; + OptionalInitializationHint x11XCBVulkanSurface = + nullopt; + }; + template + VKFW_INLINE Result setInitHint(OptionalInitializationHint optional_hint) { + if (optional_hint.has_value()) + return initHint(optional_hint.value()); + else + return Result::VKFW_ENUMERATOR(Success); + } + VKFW_INLINE Result setInitHints(InitHints hints) { + Result result = Result::VKFW_ENUMERATOR(Success); + if (!check(result = setInitHint(hints.platform))) + return result; + if (!check(result = setInitHint(hints.joystickHatButtons))) + return result; + if (!check(result = setInitHint(hints.anglePlatformType))) + return result; + if (!check(result = setInitHint(hints.cocoaChdirResources))) + return result; + if (!check(result = setInitHint(hints.cocoaMenubar))) + return result; + if (!check(result = setInitHint(hints.waylandLibDecor))) + return result; + if (!check(result = setInitHint(hints.x11XCBVulkanSurface))) + return result; + return result; + } +#endif + + VKFW_INLINE Result defaultWindowHints() { + glfwDefaultWindowHints(); + return getError(); + } + template + VKFW_INLINE Result windowHint(typename WindowHintTraits::type value) { + glfwWindowHint(static_cast(hint), static_cast(value)); + return getError(); + } +#ifndef VKFW_DISABLE_ENHANCED_MODE + template + class OptionalWindowHint : public Optional::type> { + public: + using Optional::type>::Optional; + }; + struct WindowHints { +#ifndef VKFW_NO_STRUCT_CONSTRUCTORS + public: +#if HAS_STRING_VIEW + VKFW_CONSTEXPR +#else + VKFW_INLINE +#endif + WindowHints( + OptionalWindowHint resizable_ = nullopt, + OptionalWindowHint visible_ = nullopt, + OptionalWindowHint decorated_ = nullopt, + OptionalWindowHint focused_ = nullopt, + OptionalWindowHint autoIconify_ = nullopt, + OptionalWindowHint floating_ = nullopt, + OptionalWindowHint maximized_ = nullopt, + OptionalWindowHint centerCursor_ = nullopt, + OptionalWindowHint transparentFramebuffer_ = + nullopt, + OptionalWindowHint focusOnShow_ = nullopt, + OptionalWindowHint mousePassthrough_ = nullopt, + OptionalWindowHint positionX_ = nullopt, + OptionalWindowHint positionY_ = nullopt, + OptionalWindowHint scaleToMonitor_ = nullopt, + OptionalWindowHint scaleFramebuffer_ = nullopt, + OptionalWindowHint redBits_ = nullopt, + OptionalWindowHint greenBits_ = nullopt, + OptionalWindowHint blueBits_ = nullopt, + OptionalWindowHint alphaBits_ = nullopt, + OptionalWindowHint depthBits_ = nullopt, + OptionalWindowHint stencilBits_ = nullopt, + OptionalWindowHint accumulationRedBits_ = nullopt, + OptionalWindowHint accumulationGreenBits_ = nullopt, + OptionalWindowHint accumulationBlueBits_ = nullopt, + OptionalWindowHint accumulationAlphaBits_ = nullopt, + OptionalWindowHint auxiliaryBuffers_ = nullopt, + OptionalWindowHint samples_ = nullopt, + OptionalWindowHint refreshRate_ = nullopt, + OptionalWindowHint stereo_ = nullopt, + OptionalWindowHint srgbCapable_ = nullopt, + OptionalWindowHint doubleBuffer_ = nullopt, + OptionalWindowHint clientAPI_ = ClientAPI::VKFW_ENUMERATOR(None + ), + OptionalWindowHint contextCreationAPI_ = nullopt, + OptionalWindowHint win32KeyboardMenu_ = nullopt, + OptionalWindowHint win32ShowDefault_ = nullopt, + OptionalWindowHint contextVersionMajor_ = nullopt, + OptionalWindowHint contextVersionMinor_ = nullopt, + OptionalWindowHint contextRobustness_ = nullopt, + OptionalWindowHint contextReleaseBehavior_ = + nullopt, + OptionalWindowHint contextNoError_ = nullopt, + OptionalWindowHint + openGLForwardCompatibility_ = nullopt, + OptionalWindowHint openGLDebugContext_ = nullopt, + OptionalWindowHint openGLProfile_ = nullopt, + OptionalWindowHint cocoaRetinaFramebuffer_ = + nullopt, + OptionalWindowHint cocoaFrameName_ = nullopt, + OptionalWindowHint cocoaGraphicsSwitching_ = + nullopt, + OptionalWindowHint x11ClassName_ = nullopt, + OptionalWindowHint x11InstanceName_ = nullopt, + OptionalWindowHint waylandAppID_ = nullopt + ) VKFW_NOEXCEPT : resizable(resizable_), + visible(visible_), + decorated(decorated_), + focused(focused_), + autoIconify(autoIconify_), + floating(floating_), + maximized(maximized_), + centerCursor(centerCursor_), + transparentFramebuffer(transparentFramebuffer_), + focusOnShow(focusOnShow_), + mousePassthrough(mousePassthrough_), + positionX(positionX_), + positionY(positionY_), + scaleToMonitor(scaleToMonitor_), + scaleFramebuffer(scaleFramebuffer_), + redBits(redBits_), + greenBits(greenBits_), + blueBits(blueBits_), + alphaBits(alphaBits_), + depthBits(depthBits_), + stencilBits(stencilBits_), + accumulationRedBits(accumulationRedBits_), + accumulationGreenBits(accumulationGreenBits_), + accumulationBlueBits(accumulationBlueBits_), + accumulationAlphaBits(accumulationAlphaBits_), + auxiliaryBuffers(auxiliaryBuffers_), + samples(samples_), + refreshRate(refreshRate_), + stereo(stereo_), + srgbCapable(srgbCapable_), + doubleBuffer(doubleBuffer_), + clientAPI(clientAPI_), + contextCreationAPI(contextCreationAPI_), + win32KeyboardMenu(win32KeyboardMenu_), + win32ShowDefault(win32ShowDefault_), + contextVersionMajor(contextVersionMajor_), + contextVersionMinor(contextVersionMinor_), + contextRobustness(contextRobustness_), + contextReleaseBehavior(contextReleaseBehavior_), + contextNoError(contextNoError_), + openGLForwardCompatibility(openGLForwardCompatibility_), + openGLDebugContext(openGLDebugContext_), + openGLProfile(openGLProfile_), + cocoaRetinaFramebuffer(cocoaRetinaFramebuffer_), + cocoaFrameName(cocoaFrameName_), + cocoaGraphicsSwitching(cocoaGraphicsSwitching_), + x11ClassName(x11ClassName_), + x11InstanceName(x11InstanceName_), + waylandAppID(waylandAppID_) {} +#endif + public: + OptionalWindowHint resizable = nullopt; + OptionalWindowHint visible = nullopt; + OptionalWindowHint decorated = nullopt; + OptionalWindowHint focused = nullopt; + OptionalWindowHint autoIconify = nullopt; + OptionalWindowHint floating = nullopt; + OptionalWindowHint maximized = nullopt; + OptionalWindowHint centerCursor = nullopt; + OptionalWindowHint transparentFramebuffer = nullopt; + OptionalWindowHint focusOnShow = nullopt; + OptionalWindowHint mousePassthrough = nullopt; + OptionalWindowHint positionX = nullopt; + OptionalWindowHint positionY = nullopt; + OptionalWindowHint scaleToMonitor = nullopt; + OptionalWindowHint scaleFramebuffer = nullopt; + OptionalWindowHint redBits = nullopt; + OptionalWindowHint greenBits = nullopt; + OptionalWindowHint blueBits = nullopt; + OptionalWindowHint alphaBits = nullopt; + OptionalWindowHint depthBits = nullopt; + OptionalWindowHint stencilBits = nullopt; + OptionalWindowHint accumulationRedBits = nullopt; + OptionalWindowHint accumulationGreenBits = nullopt; + OptionalWindowHint accumulationBlueBits = nullopt; + OptionalWindowHint accumulationAlphaBits = nullopt; + OptionalWindowHint auxiliaryBuffers = nullopt; + OptionalWindowHint samples = nullopt; + OptionalWindowHint refreshRate = nullopt; + OptionalWindowHint stereo = nullopt; + OptionalWindowHint srgbCapable = nullopt; + OptionalWindowHint doubleBuffer = nullopt; + OptionalWindowHint clientAPI = ClientAPI::VKFW_ENUMERATOR(None); + OptionalWindowHint contextCreationAPI = nullopt; + OptionalWindowHint win32KeyboardMenu = nullopt; + OptionalWindowHint win32ShowDefault = nullopt; + OptionalWindowHint contextVersionMajor = nullopt; + OptionalWindowHint contextVersionMinor = nullopt; + OptionalWindowHint contextRobustness = nullopt; + OptionalWindowHint contextReleaseBehavior = nullopt; + OptionalWindowHint contextNoError = nullopt; + OptionalWindowHint openGLForwardCompatibility = + nullopt; + OptionalWindowHint openGLDebugContext = nullopt; + OptionalWindowHint openGLProfile = nullopt; + OptionalWindowHint cocoaRetinaFramebuffer = nullopt; + OptionalWindowHint cocoaFrameName = nullopt; + OptionalWindowHint cocoaGraphicsSwitching = nullopt; + OptionalWindowHint x11ClassName = nullopt; + OptionalWindowHint x11InstanceName = nullopt; + OptionalWindowHint waylandAppID = nullopt; + }; + template + Result setWindowHint(OptionalWindowHint optional_hint) { + if (optional_hint.has_value()) + return windowHint(optional_hint.value()); + else + return Result::VKFW_ENUMERATOR(Success); + } + VKFW_INLINE Result setWindowHints(WindowHints const& hints) { + Result result = Result::VKFW_ENUMERATOR(Success); + if (!check(result = setWindowHint(hints.resizable))) + return result; + if (!check(result = setWindowHint(hints.visible))) + return result; + if (!check(result = setWindowHint(hints.decorated))) + return result; + if (!check(result = setWindowHint(hints.focused))) + return result; + if (!check(result = setWindowHint(hints.autoIconify))) + return result; + if (!check(result = setWindowHint(hints.floating))) + return result; + if (!check(result = setWindowHint(hints.maximized))) + return result; + if (!check(result = setWindowHint(hints.centerCursor))) + return result; + if (!check(result = setWindowHint(hints.transparentFramebuffer))) + return result; + if (!check(result = setWindowHint(hints.focusOnShow))) + return result; + if (!check(result = setWindowHint(hints.mousePassthrough))) + return result; + if (!check(result = setWindowHint(hints.positionX))) + return result; + if (!check(result = setWindowHint(hints.positionY))) + return result; + if (!check(result = setWindowHint(hints.scaleToMonitor))) + return result; + if (!check(result = setWindowHint(hints.scaleFramebuffer))) + return result; + if (!check(result = setWindowHint(hints.redBits))) + return result; + if (!check(result = setWindowHint(hints.greenBits))) + return result; + if (!check(result = setWindowHint(hints.blueBits))) + return result; + if (!check(result = setWindowHint(hints.alphaBits))) + return result; + if (!check(result = setWindowHint(hints.depthBits))) + return result; + if (!check(result = setWindowHint(hints.stencilBits))) + return result; + if (!check(result = setWindowHint(hints.accumulationRedBits))) + return result; + if (!check(result = setWindowHint(hints.accumulationGreenBits))) + return result; + if (!check(result = setWindowHint(hints.accumulationBlueBits))) + return result; + if (!check(result = setWindowHint(hints.accumulationAlphaBits))) + return result; + if (!check(result = setWindowHint(hints.auxiliaryBuffers))) + return result; + if (!check(result = setWindowHint(hints.samples))) + return result; + if (!check(result = setWindowHint(hints.refreshRate))) + return result; + if (!check(result = setWindowHint(hints.stereo))) + return result; + if (!check(result = setWindowHint(hints.srgbCapable))) + return result; + if (!check(result = setWindowHint(hints.doubleBuffer))) + return result; + if (!check(result = setWindowHint(hints.clientAPI))) + return result; + if (!check(result = setWindowHint(hints.contextCreationAPI))) + return result; + if (!check(result = setWindowHint(hints.win32KeyboardMenu))) + return result; + if (!check(result = setWindowHint(hints.win32ShowDefault))) + return result; + if (!check(result = setWindowHint(hints.contextVersionMajor))) + return result; + if (!check(result = setWindowHint(hints.contextVersionMinor))) + return result; + if (!check(result = setWindowHint(hints.contextRobustness))) + return result; + if (!check(result = setWindowHint(hints.contextReleaseBehavior))) + return result; + if (!check(result = setWindowHint(hints.contextNoError))) + return result; + if (!check(result = setWindowHint(hints.openGLForwardCompatibility))) + return result; + if (!check(result = setWindowHint(hints.openGLDebugContext))) + return result; + if (!check(result = setWindowHint(hints.openGLProfile))) + return result; + if (!check(result = setWindowHint(hints.cocoaRetinaFramebuffer))) + return result; + if (!check(result = setWindowHint(hints.cocoaFrameName))) + return result; + if (!check(result = setWindowHint(hints.cocoaGraphicsSwitching))) + return result; + if (!check(result = setWindowHint(hints.x11ClassName))) + return result; + if (!check(result = setWindowHint(hints.x11InstanceName))) + return result; + if (!check(result = setWindowHint(hints.waylandAppID))) + return result; + return result; + } +#endif + + template + VKFW_INLINE Result set(typename InitializationHintTraits::type value) { + return initHint(std::move(value)); + } + template + VKFW_INLINE Result set(typename WindowHintTraits::type value) { + return windowHint(std::move(value)); + } + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD Result init(); + VKFW_NODISCARD Result terminate(); +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type init(InitHints hints = {}); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type terminate(); +#ifndef VKFW_NO_SMART_HANDLE + using UniqueInstance = UniqueHandle; + VKFW_NODISCARD typename ResultValueType::type initUnique(InitHints hints = {}); +#endif +#endif + + struct Version { + size_t major, minor, revision; + }; + VKFW_INLINE Version getVersion() { + int major, minor, revision; + glfwGetVersion(&major, &minor, &revision); + return Version { static_cast(major), static_cast(minor), static_cast(revision) }; + } + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_INLINE std::string_view getVersionString() { +#else + VKFW_INLINE char const* getVersionString() { +#endif + return glfwGetVersionString(); + } + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD GLFWmonitor* getPrimaryMonitor(); +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD std::span getMonitors(); +#else + VKFW_NODISCARD GLFWmonitor** getMonitors(size_t* count); +#endif +#else + VKFW_NODISCARD typename ResultValueType::type getPrimaryMonitor(); + VKFW_NODISCARD typename ResultValueType>::type getMonitors(); +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + void getMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos); + void getMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, size_t* width, size_t* height); + void getMonitorPhysicalSize(GLFWmonitor* monitor, size_t* widthMM, size_t* heightMM); + void getMonitorContentScale(GLFWmonitor* monitor, float* xscale, float* yscale); + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD std::string_view getMonitorName(); +#else + VKFW_NODISCARD char const* getMonitorName(); +#endif + + void setMonitorUserPointer(GLFWmonitor* monitor, void* pointer); + VKFW_NODISCARD void* getMonitorUserPointer(GLFWmonitor* monitor); + + VKFW_NODISCARD GLFWvidmode const* getVideoMode(GLFWmonitor* monitor); +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD std::span getVideoModes(GLFWmonitor* monitor); +#else + VKFW_NODISCARD GLFWvidmode const* getVideoModes(GLFWmonitor* monitor, size_t* count); +#endif + + void setGamma(GLFWmonitor* monitor, float gamma); + VKFW_NODISCARD GLFWgammaramp const* getGammaRamp(GLFWmonitor* monitor); + void setGammaRamp(GLFWmonitor* monitor, GLFWgammaramp const* ramp); +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD GLFWwindow* createWindow( + size_t width, + size_t height, + char const* title, + GLFWmonitor* monitor = nullptr, + GLFWwindow* share = nullptr + ); + VKFW_NODISCARD Result destroyWindow(GLFWwindow* window); +#else + VKFW_NODISCARD typename ResultValueType::type createWindow( + size_t width, + size_t height, + char const* title, + WindowHints hints = WindowHints {}, + Monitor monitor = nullptr, + Window share = nullptr, + bool reset_hints = true + ); +#ifndef VKFW_NO_SMART_HANDLE + using UniqueWindow = UniqueHandle; + VKFW_NODISCARD typename ResultValueType::type createWindowUnique( + size_t width, + size_t height, + char const* title, + WindowHints const& hints = WindowHints {}, + Monitor monitor = nullptr, + Window share = nullptr, + bool reset_hints = true + ); +#endif +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + bool windowShouldClose(GLFWwindow* window); + void setWindowShouldClose(GLFWwindow* window, bool value); + +#ifdef VKFW_HAS_STRING_VIEW + void setWindowTitle(GLFWwindow* window, std::string_view title); +#else + void setWindowTitle(GLFWwindow* window, char const* title); +#endif + + void getWindowPos(GLFWwindow* window, int* xpos, int* ypos); + void setWindowPos(GLFWwindow* window, int xpos, int ypos); + void getWindowSize(GLFWwindow* window, size_t* width, size_t* height); + void setWindowSizeLimits( + GLFWwindow* window, + size_t minimum_width, + size_t minimum_height, + size_t maximum_width, + size_t maximum_height + ); + void setWindowAspectRatio(GLFWwindow* window, size_t numerator, size_t denominator); + void setWindowSize(GLFWwindow* window, size_t width, size_t height); + void getFramebufferSize(GLFWwindow* window, size_t* width, size_t* height); + void getWindowFrameSize(GLFWwindow* window, size_t* left, size_t* top, size_t* right, size_t* bottom); + void getWindowContentScale(GLFWwindow* window, float* xscale, float* yscale); + float getWindowOpacity(GLFWwindow* window); + void setWindowOpacity(GLFWwindow* window, float opacity); + void iconifyWindow(GLFWwindow* window); + void restoreWindow(GLFWwindow* window); + void maximizeWindow(GLFWwindow* window); + void showWindow(GLFWwindow* window); + void hideWindow(GLFWwindow* window); + void focusWindow(GLFWwindow* window); + void requestWindowAttention(GLFWwindow* window); + GLFWmonitor* getWindowMonitor(GLFWwindow* window); + void setWindowMonitor( + GLFWwindow* window, + GLFWmonitor* monitor, + int xpos, + int ypos, + size_t width, + size_t height, + size_t refreshRate + ); + +#ifdef VKFW_HAS_SPAN + void setWindowIcon(std::span images); +#endif + void setWindowIcon(GLFWwindow* window, std::vector images); + void setWindowIcon(GLFWwindow* window, int count, vkfw::Image const* images); + + template + VKFW_NODISCARD typename ResultValueType::type>::type getWindowAttribute( + GLFWwindow* window + ); + template ::value>::type> + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setWindowAttribute(GLFWwindow* window, typename AttributeTraits::type const& new_value); + + template + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type>::type get( + GLFWwindow* window + ) { + return getWindowAttribute(window); + } + template ::value>::type> + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + set(GLFWwindow* window, typename AttributeTraits::type const& new_value) { + return setWindowAttribute(window, new_value); + } + + template + VKFW_NODISCARD typename ResultValueType::type>::type getInputMode( + GLFWwindow* window + ); + template + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setInputMode(GLFWwindow* window, typename InputModeTraits::type const& new_value); + + template + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type>::type get( + GLFWwindow* window + ) { + return getInputMode(window); + } + template + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + set(GLFWwindow* window, typename InputModeTraits::type const& new_value) { + return setInputMode(window, new_value); + } + +#ifdef VKFW_NO_STD_FUNCTION_CALLBACKS + VKFW_INLINE GLFWwindowposfun setWindowPosCallback(GLFWwindow* window, GLFWwindowposfun callback) { + return glfwSetWindowPosCallback(window, callback); + } + VKFW_INLINE GLFWwindowsizefun setWindowSizeCallback(GLFWwindow* window, GLFWwindowsizefun callback) { + return glfwSetWindowSizeCallback(window, callback); + } + VKFW_INLINE GLFWwindowclosefun setWindowCloseCallback(GLFWwindow* window, GLFWwindowclosefun callback) { + return glfwSetWindowCloseCallback(window, callback); + } + VKFW_INLINE GLFWwindowrefreshfun + setWindowRefreshCallback(GLFWwindow* window, GLFWwindowrefreshfun callback) { + return glfwSetWindowRefreshCallback(window, callback); + } + VKFW_INLINE GLFWwindowfocusfun setWindowFocusCallback(GLFWwindow* window, GLFWwindowfocusfun callback) { + return glfwSetWindowFocusCallback(window, callback); + } + VKFW_INLINE GLFWwindowiconifyfun + setWindowIconifyCallback(GLFWwindow* window, GLFWwindowiconifyfun callback) { + return glfwSetWindowIconifyCallback(window, callback); + } + VKFW_INLINE GLFWwindowmaximizefun + setWindowMaximizeCallback(GLFWwindow* window, GLFWwindowmaximizefun callback) { + return glfwSetWindowMaximizeCallback(window, callback); + } + VKFW_INLINE GLFWframebuffersizefun + setFramebufferSizeCallback(GLFWwindow* window, GLFWframebuffersizefun callback) { + return glfwSetFramebufferSizeCallback(window, callback); + } + VKFW_INLINE GLFWwindowcontentscalefun + setWindowContentScaleCallback(GLFWwindow* window, GLFWwindowcontentscalefun callback) { + return glfwSetWindowContentScaleCallback(window, callback); + } + VKFW_INLINE GLFWkeyfun setKeyCallback(GLFWwindow* window, GLFWkeyfun callback) { + return glfwSetKeyCallback(window, callback); + } + VKFW_INLINE GLFWcharfun setCharCallback(GLFWwindow* window, GLFWcharfun callback) { + return glfwSetCharCallback(window, callback); + } + VKFW_INLINE GLFWcharmodsfun setCharModsCallback(GLFWwindow* window, GLFWcharmodsfun callback) { + return glfwSetCharModsCallback(window, callback); + } + VKFW_INLINE GLFWmousebuttonfun setMouseButtonCallback(GLFWwindow* window, GLFWmousebuttonfun callback) { + return glfwSetMouseButtonCallback(window, callback); + } + VKFW_INLINE GLFWcursorposfun setCursorPosCallback(GLFWwindow* window, GLFWcursorposfun callback) { + return glfwSetCursorPosCallback(window, callback); + } + VKFW_INLINE GLFWcursorenterfun setCursorEnterCallback(GLFWwindow* window, GLFWcursorenterfun callback) { + return glfwSetCursorEnterCallback(window, callback); + } + VKFW_INLINE GLFWscrollfun setScrollCallback(GLFWwindow* window, GLFWscrollfun callback) { + return glfwSetScrollCallback(window, callback); + } + VKFW_INLINE GLFWdropfun setDropCallback(GLFWwindow* window, GLFWdropfun callback) { + return glfwSetDropCallback(window, callback); + } +#else + VKFW_NODISCARD VKFW_INLINE DynamicCallbackStorage* accessWindowCallbacks(GLFWwindow* window) { + return reinterpret_cast(glfwGetWindowUserPointer(window)); + } +#endif + VKFW_NODISCARD typename ResultValueType::type getWindowUserPointer(GLFWwindow* window); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type + setWindowUserPointer(GLFWwindow* window, void* pointer); + + VKFW_NODISCARD bool getKey(GLFWwindow* window, Key key); + VKFW_NODISCARD bool getMouseButton(GLFWwindow* window, MouseButton button); + void getCursorPos(GLFWwindow* window, double* xpos, double* ypos); + void setCursorPos(GLFWwindow* window, double xpos, double ypos); + void setCursor(GLFWwindow* window, GLFWcursor* cursor); +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + void pollEvents(); + void waitEvents(); + void waitEventsTimeout(double timeout); + void postEmptyEvent(); + + void makeContextCurrent(GLFWwindow* window); + VKFW_NODISCARD GLFWwindow* getCurrentContext(); + void swapBuffers(GLFWwindow* window); + void swapInterval(int interval); + + VKFW_NODISCARD bool rawMouseMotionSupported(); + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD std::string_view getKeyName(Key key, int scancode = 0); +#else + VKFW_NODISCARD char const* getKeyName(Key key, int scancode = 0); +#endif + VKFW_NODISCARD int getKeyScancode(Key key); +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type pollEvents(); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitEvents(); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitEventsTimeout(double timeout); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type waitEventsTimeout( + std::chrono::duration timeout + ); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type postEmptyEvent(); + + VKFW_NODISCARD typename ResultValueType::type getCurrentContext(); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type swapInterval(int interval); + + VKFW_NODISCARD typename ResultValueType::type rawMouseMotionSupported(); + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD typename ResultValueType::type getKeyName(Key key, int32_t scancode = 0); +#else + VKFW_NODISCARD typename ResultValueType::type getKeyName(Key key, int32_t scancode = 0); +#endif + VKFW_NODISCARD typename ResultValueType::type getKeyScancode(Key key); +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD GLFWcursor* createCursor(vkfw::Image const* image, int xhot, int yhot); + VKFW_NODISCARD GLFWcursor* createStandardCursor(CursorShape shape); + VKFW_NODISCARD Result destroyCursor(GLFWcursor* cursor); +#else + VKFW_NODISCARD typename ResultValueType::type + createCursor(vkfw::Image const& image, int xhot, int yhot); + VKFW_NODISCARD typename ResultValueType::type createStandardCursor(CursorShape shape); +#ifndef VKFW_NO_SMART_HANDLE + using UniqueCursor = UniqueHandle; + VKFW_NODISCARD typename ResultValueType::type + createCursorUnique(vkfw::Image const& image, int xhot, int yhot); + VKFW_NODISCARD typename ResultValueType::type createStandardCursorUnique(CursorShape shape); +#endif +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE +#ifdef VKFW_HAS_STRING_VIEW + void setClipboardString(std::string_view string); + std::string_view getClipboardString(); +#else + void setClipboardString(char const* string); + char const* getClipboardString(); +#endif + + double getTime(); + void setTime(double time); + uint64_t getTimerValue(); + uint64_t getTimerFrequency(); +#else +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setClipboardString( + std::string_view string + ); + VKFW_NODISCARD typename ResultValueType::type getClipboardString(); +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setClipboardString(char const* string + ); + VKFW_NODISCARD typename ResultValueType::type getClipboardString(); +#endif + + VKFW_NODISCARD typename ResultValueType::type getTime(); + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType::type setTime(double time); + VKFW_NODISCARD typename ResultValueType::type getTimerValue(); + VKFW_NODISCARD typename ResultValueType::type getTimerFrequency(); +#endif + + VKFW_NODISCARD VKFW_INLINE bool joystickPresent(Joystick jid) { + return static_cast(glfwJoystickPresent(static_cast(jid))); + } + VKFW_NODISCARD VKFW_INLINE float const* getJoystickAxes(Joystick jid, int* count) { + return glfwGetJoystickAxes(static_cast(jid), count); + } + VKFW_NODISCARD VKFW_INLINE const unsigned char* getJoystickButtons(Joystick jid, int* count) { + return glfwGetJoystickButtons(static_cast(jid), count); + } + VKFW_NODISCARD VKFW_INLINE const unsigned char* getJoystickHats(Joystick jid, int* count) { + return glfwGetJoystickHats(static_cast(jid), count); + } +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE std::string_view getJoystickName(Joystick jid) { + return glfwGetJoystickName(static_cast(jid)); + } + VKFW_NODISCARD VKFW_INLINE std::string_view getJoystickGUID(Joystick jid) { + return glfwGetJoystickGUID(static_cast(jid)); + } +#else + VKFW_NODISCARD VKFW_INLINE char const* getJoystickName(Joystick jid) { + return glfwGetJoystickName(static_cast(jid)); + } + VKFW_NODISCARD VKFW_INLINE char const* getJoystickGUID(Joystick jid) { + return glfwGetJoystickGUID(static_cast(jid)); + } +#endif + VKFW_INLINE void getJoystickUserPointer(Joystick jid, void* pointer) { + glfwSetJoystickUserPointer(static_cast(jid), pointer); + } + VKFW_NODISCARD VKFW_INLINE void* getJoystickUserPointer(Joystick jid) { + return glfwGetJoystickUserPointer(static_cast(jid)); + } + VKFW_NODISCARD VKFW_INLINE bool joystickIsGamepad(Joystick jid) { + return static_cast(glfwJoystickIsGamepad(static_cast(jid))); + } + VKFW_INLINE GLFWjoystickfun setJoystickCallback(GLFWjoystickfun callback) { + return glfwSetJoystickCallback(callback); + } +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE bool updateGamepadMappings(std::string_view string) { + return static_cast(glfwUpdateGamepadMappings(string.data())); + } +#endif + VKFW_NODISCARD VKFW_INLINE bool updateGamepadMappings(char const* string) { + return static_cast(glfwUpdateGamepadMappings(string)); + } +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE char const* getGamepadName(Joystick jid) { + return glfwGetGamepadName(static_cast(jid)); + } +#else + VKFW_NODISCARD VKFW_INLINE char const* getGamepadName(Joystick jid) { + return glfwGetGamepadName(static_cast(jid)); + } +#endif + VKFW_NODISCARD VKFW_INLINE bool getGamepadState(Joystick jid, GLFWgamepadstate* state) { + return static_cast(glfwGetGamepadState(static_cast(jid), state)); + } + + VKFW_NODISCARD VKFW_INLINE bool extensionSupported(char const* extension) { + return static_cast(glfwExtensionSupported(extension)); + } + VKFW_NODISCARD VKFW_INLINE GLFWglproc getProcAddress(char const* procname) { + return glfwGetProcAddress(procname); + } + VKFW_NODISCARD VKFW_INLINE bool vulkanSupported() { return glfwVulkanSupported(); } + VKFW_INLINE void initVulkanLoader(PFN_vkGetInstanceProcAddr loader) { return glfwInitVulkanLoader(loader); } + +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD VKFW_INLINE std::span getRequiredInstanceExtensions() { + uint32_t count; + auto pointer = glfwGetRequiredInstanceExtensions(&count); + return std::span(pointer, count); + } +#endif + VKFW_NODISCARD VKFW_INLINE char const** getRequiredInstanceExtensions(uint32_t* count) { + return glfwGetRequiredInstanceExtensions(count); + } +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE GLFWvkproc + getInstanceProcAddress(VkInstance instance, std::string_view procname) { + return glfwGetInstanceProcAddress(instance, procname.data()); + } +#endif +#if !defined(VKFW_NO_INCLUDE_VULKAN) + VKFW_NODISCARD VKFW_INLINE GLFWvkproc getInstanceProcAddress(VkInstance instance, char const* procname) { + return glfwGetInstanceProcAddress(instance, procname); + } + VKFW_NODISCARD VKFW_INLINE bool + getPhysicalDevicePresentationSupport(VkInstance instance, VkPhysicalDevice device, uint32_t queuefamily) { + return static_cast(glfwGetPhysicalDevicePresentationSupport(instance, device, queuefamily)); + } +#endif +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_INLINE VkResult createWindowSurface( + VkInstance instance, + GLFWwindow* window, + VkAllocationCallbacks const* allocator, + VkSurfaceKHR* surface + ) { + return glfwCreateWindowSurface(instance, window, allocator, surface); + } +#else +#ifndef VKFW_NO_INCLUDE_VULKAN_HPP + VKFW_NODISCARD VKFW_INLINE vk::SurfaceKHR createWindowSurface( + vk::Instance const& instance, + Window const& window, + VkAllocationCallbacks const* allocator = nullptr + ) { + VkSurfaceKHR output; + glfwCreateWindowSurface(instance, window, allocator, &output); + return output; + } +#ifndef VKFW_NO_SMART_HANDLE + VKFW_NODISCARD VKFW_INLINE vk::UniqueSurfaceKHR createWindowSurfaceUnique( + vk::Instance const& instance, + Window const& window, + VkAllocationCallbacks const* allocator = nullptr + ) { + VkSurfaceKHR output; + glfwCreateWindowSurface(instance, window, allocator, &output); + + vk::ObjectDestroy deleter(instance, nullptr); + return vk::UniqueSurfaceKHR(output, deleter); + } +#endif +#endif +#endif +} // namespace VKFW_NAMESPACE + +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS +namespace VKFW_NAMESPACE { + struct DynamicCallbackStorage { +#ifdef VKFW_DISABLE_ENHANCED_MODE + friend void* VKFW_NAMESPACE::getWindowUserPointer(GLFWwindow* window); + friend void VKFW_NAMESPACE::setWindowUserPointer(GLFWwindow* window, void* pointer); + using window_type = GLFWwindow*; +#else + friend class Window; + using window_type = Window const&; +#endif + private: + void* user_ptr = nullptr; + + public: + std::function on_window_move; + std::function on_window_resize; + std::function on_window_close; + std::function on_window_refresh; + std::function on_window_focus; + std::function on_window_iconify; + std::function on_window_maximize; + std::function on_framebuffer_resize; + std::function on_window_content_scale_change; + std::function on_mouse_button; + std::function on_cursor_move; + std::function on_cursor_enter; + std::function on_scroll; + std::function on_key; + std::function on_character; +#ifdef VKFW_HAS_STRING_VIEW + std::function)> on_drop; +#else + std::function)> on_drop; +#endif + }; +} // namespace VKFW_NAMESPACE +#endif + +#ifndef VKFW_NO_SMART_HANDLE +template <> +struct VKFW_NAMESPACE::CustomDestroy { + VKFW_INLINE void destroy(Instance& instance) { static_cast(instance.destroy()); } +}; +#ifndef VKFW_NO_INCLUDE_VULKAN_HPP +template <> +class VULKAN_HPP_NAMESPACE::UniqueHandleTraits { +#else +template <> +class VKFW_NAMESPACE::UniqueHandleTraits { +#endif + public: + using deleter = VKFW_NAMESPACE::CustomDestroy; +}; + +template <> +struct VKFW_NAMESPACE::CustomDestroy { + VKFW_INLINE void destroy(Window& window) { static_cast(window.destroy()); } +}; +#ifndef VKFW_NO_INCLUDE_VULKAN_HPP +template <> +class VULKAN_HPP_NAMESPACE::UniqueHandleTraits { +#else +template <> +class VKFW_NAMESPACE::UniqueHandleTraits { +#endif + public: + using deleter = VKFW_NAMESPACE::CustomDestroy; +}; + +template <> +struct VKFW_NAMESPACE::CustomDestroy { + VKFW_INLINE void destroy(Cursor& cursor) { static_cast(cursor.destroy()); } +}; +#ifndef VKFW_NO_INCLUDE_VULKAN_HPP +template <> +class VULKAN_HPP_NAMESPACE::UniqueHandleTraits { +#else +template <> +class VKFW_NAMESPACE::UniqueHandleTraits { +#endif + public: + using deleter = VKFW_NAMESPACE::CustomDestroy; +}; +#endif + +namespace VKFW_NAMESPACE { +#ifndef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Instance::destroy() { + if (m_state) { + glfwTerminate(); + m_state = false; + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Instance::destroy"); + } else + return createResultValue(Result::VKFW_ENUMERATOR(Success), VKFW_NAMESPACE_STRING "::Instance::destroy"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::destroy() { + if (m_window) { +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(m_window)); + if (ptr) + delete ptr; +#endif + glfwDestroyWindow(m_window); + m_window = nullptr; + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::destroy"); + } else + return createResultValue(Result::VKFW_ENUMERATOR(Success), VKFW_NAMESPACE_STRING "::Window::destroy"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Cursor::destroy() { + glfwDestroyCursor(m_cursor); + m_cursor = nullptr; + return createResultValue(Result::VKFW_ENUMERATOR(Success), VKFW_NAMESPACE_STRING "::Cursor::destroy"); + } +#endif + +#ifdef VKFW_HAS_STRING_VIEW + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(CocoaFrameName)), value.data()); + return getError(); + } +#else + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(CocoaFrameName)), value); + return getError(); + } +#endif +#ifdef VKFW_HAS_STRING_VIEW + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(X11ClassName)), value.data()); + return getError(); + } +#else + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(X11ClassName)), value); + return getError(); + } +#endif +#ifdef VKFW_HAS_STRING_VIEW + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(X11InstanceName)), value.data()); + return getError(); + } +#else + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(X11InstanceName)), value); + return getError(); + } +#endif +#ifdef VKFW_HAS_STRING_VIEW + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(WaylandAppID)), value.data()); + return getError(); + } +#else + template <> + VKFW_INLINE Result windowHint( + typename WindowHintTraits::type value + ) { + glfwWindowHintString(static_cast(WindowHint::VKFW_ENUMERATOR(WaylandAppID)), value); + return getError(); + } +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD VKFW_INLINE Result init() { + if (glfwInit()) + return Result::VKFW_ENUMERATOR(Success); + else + return getError(); + } + VKFW_NODISCARD VKFW_INLINE Result terminate() { + glfwTerminate(); + return getError(); + } +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type init(InitHints hints) { + Result result = setInitHints(hints); + if (!check(result)) + return createResultValue(result, VKFW_NAMESPACE_STRING "::init"); + + if (glfwInit()) + return createResultValue(Result::VKFW_ENUMERATOR(Success), VKFW_NAMESPACE_STRING "::init"); + else + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::init"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type terminate() { + glfwTerminate(); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::terminate"); + } +#ifndef VKFW_NO_SMART_HANDLE + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type initUnique( + InitHints hints + ) { + Instance instance; + + Result result = setInitHints(hints); + if (!check(result)) + return createResultValueUnique(result, instance, VKFW_NAMESPACE_STRING "::initUnique"); + + if (glfwInit()) { + instance = true; + return createResultValueUnique( + Result::VKFW_ENUMERATOR(Success), instance, VKFW_NAMESPACE_STRING "::initUnique" + ); + } else + return createResultValueUnique(getError(), instance, VKFW_NAMESPACE_STRING "::initUnique"); + } +#endif +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD VKFW_INLINE GLFWmonitor* getPrimaryMonitor() { return glfwGetPrimaryMonitor(); } +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD VKFW_INLINE std::span getMonitors() { + int tmp_count; + auto** output = glfwGetMonitors(&tmp_count); + return std::span(output, static_cast(tmp_count > 0 ? tmp_count : 0)); + } +#else + VKFW_NODISCARD VKFW_INLINE GLFWmonitor** getMonitors(size_t* count) { + int tmp_count; + auto** output = glfwGetMonitors(&tmp_count); + *count = static_cast(tmp_count > 0 ? tmp_count : 0); + return output; + } +#endif +#else + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getPrimaryMonitor() { + Monitor monitor = glfwGetPrimaryMonitor(); + return createResultValue(getError(), monitor, VKFW_NAMESPACE_STRING "::getPrimaryMonitor"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type getMonitors() { + std::vector output; + + int count; + auto ptr = glfwGetMonitors(&count); + Result result = getError(); + if (check(result)) { + output.reserve(static_cast(count)); + std::transform(ptr, ptr + count, std::back_inserter(output), [](GLFWmonitor* monitor) { + return Monitor(monitor); + }); + VKFW_ASSERT(output.size() == static_cast(count)); + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::getMonitors"); + } +#endif + VKFW_INLINE GLFWmonitorfun setMonitorCallback(GLFWmonitorfun const& callback) { + return glfwSetMonitorCallback(callback); + } + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_INLINE void getMonitorPos(GLFWmonitor* monitor, int* xpos, int* ypos) { + glfwGetMonitorPos(monitor, xpos, ypos); + } + VKFW_INLINE void + getMonitorWorkarea(GLFWmonitor* monitor, int* xpos, int* ypos, size_t* width, size_t* height) { + int temp_width, temp_height; + glfwGetMonitorWorkarea(monitor, xpos, ypos, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *width = temp_width; + *height = temp_height; + } else { + *width = 0u; + *height = 0u; + } + } + VKFW_INLINE void getMonitorPhysicalSize(GLFWmonitor* monitor, size_t* widthMM, size_t* heightMM) { + int temp_width, temp_height; + glfwGetMonitorPhysicalSize(monitor, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *widthMM = temp_width; + *heightMM = temp_height; + } else { + *widthMM = 0u; + *heightMM = 0u; + } + } + VKFW_INLINE void getMonitorContentScale(GLFWmonitor* monitor, float* xscale, float* yscale) { + glfwGetMonitorContentScale(monitor, xscale, yscale); + } +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE std::string_view getMonitorName(GLFWmonitor* monitor) { +#else + VKFW_NODISCARD VKFW_INLINE char const* getMonitorName(GLFWmonitor* monitor) { +#endif + return glfwGetMonitorName(monitor); + } + + VKFW_INLINE void setMonitorUserPointer(GLFWmonitor* monitor, void* pointer) { + glfwSetMonitorUserPointer(monitor, pointer); + } + VKFW_NODISCARD VKFW_INLINE void* getMonitorUserPointer(GLFWmonitor* monitor) { + return glfwGetMonitorUserPointer(monitor); + } + + VKFW_NODISCARD VKFW_INLINE GLFWvidmode const* getVideoMode(GLFWmonitor* monitor) { + return glfwGetVideoMode(monitor); + } +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD VKFW_INLINE std::span getVideoModes(GLFWmonitor* monitor) { + int count; + GLFWvidmode const* pointer = glfwGetVideoModes(monitor, &count); + return std::span(pointer, static_cast(count)); + } +#else + VKFW_NODISCARD VKFW_INLINE GLFWvidmode const* getVideoModes(GLFWmonitor* monitor, size_t* count) { + int temp_count; + GLFWvidmode const* pointer = glfwGetVideoModes(monitor, &temp_count); + if (temp_count > 0) + *count = temp_count; + else + *count = 0u; + return pointer; + } +#endif + + VKFW_INLINE void setGamma(GLFWmonitor* monitor, float gamma) { glfwSetGamma(monitor, gamma); } + VKFW_NODISCARD VKFW_INLINE GLFWgammaramp const* getGammaRamp(GLFWmonitor* monitor) { + return glfwGetGammaRamp(monitor); + } + VKFW_INLINE void setGammaRamp(GLFWmonitor* monitor, GLFWgammaramp const* ramp) { + glfwSetGammaRamp(monitor, ramp); + } +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Monitor::getPos(int* xpos, int* ypos) const { + glfwGetMonitorPos(m_monitor, xpos, ypos); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::getPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Monitor::getPos() const { + std::tuple output; + glfwGetMonitorPos(m_monitor, &std::get<0>(output), &std::get<1>(output)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getPosX() const { + int output; + glfwGetMonitorPos(m_monitor, &output, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getPosX"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getPosY() const { + int output; + glfwGetMonitorPos(m_monitor, nullptr, &output); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getPosY"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Monitor::getWorkarea(int* xpos, int* ypos, size_t* width, size_t* height) const { + int temp_width, temp_height; + glfwGetMonitorWorkarea(m_monitor, xpos, ypos, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *width = temp_width; + *height = temp_height; + } else { + *width = 0u; + *height = 0u; + } + return createResultValue(result, VKFW_NAMESPACE_STRING "::Monitor::getWorkarea"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Monitor::getWorkarea() const { + std::tuple output; + int temp_width, temp_height; + glfwGetMonitorWorkarea(m_monitor, &std::get<0>(output), &std::get<1>(output), &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + std::get<2>(output) = temp_width; + std::get<3>(output) = temp_height; + } else { + std::get<2>(output) = 0u; + std::get<3>(output) = 0u; + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getWorkarea"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Monitor::getWorkareaPos( + ) const { + std::tuple output; + glfwGetMonitorWorkarea(m_monitor, &std::get<0>(output), &std::get<1>(output), nullptr, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getWorkareaPosX() const { + int output; + glfwGetMonitorWorkarea(m_monitor, &output, nullptr, nullptr, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaPosX"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getWorkareaPosY() const { + int output; + glfwGetMonitorWorkarea(m_monitor, nullptr, &output, nullptr, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaPosY"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Monitor::getWorkareaSize() const { + std::tuple output; + int temp_width, temp_height; + glfwGetMonitorWorkarea(m_monitor, nullptr, nullptr, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + std::get<0>(output) = temp_width; + std::get<1>(output) = temp_height; + } else { + std::get<0>(output) = 0u; + std::get<1>(output) = 0u; + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getWorkareaWidth() const { + size_t output; + int temp; + glfwGetMonitorWorkarea(m_monitor, nullptr, nullptr, &temp, nullptr); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaWidth"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getWorkareaHeight() const { + size_t output; + int temp; + glfwGetMonitorWorkarea(m_monitor, nullptr, nullptr, nullptr, &temp); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaHeight"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Monitor::getPhysicalSize(size_t* widthMM, size_t* heightMM) const { + int temp_width, temp_height; + glfwGetMonitorPhysicalSize(m_monitor, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *widthMM = temp_width; + *heightMM = temp_height; + } else { + *widthMM = 0u; + *heightMM = 0u; + } + return createResultValue(result, VKFW_NAMESPACE_STRING "::Monitor::getPhysicalSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Monitor::getPhysicalSize() const { + std::tuple output; + int temp_width, temp_height; + glfwGetMonitorPhysicalSize(m_monitor, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + std::get<0>(output) = temp_width; + std::get<1>(output) = temp_height; + } else { + std::get<0>(output) = 0u; + std::get<1>(output) = 0u; + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getPhysicalSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getPhysicalWidth() const { + size_t output; + int temp; + glfwGetMonitorPhysicalSize(m_monitor, &temp, nullptr); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getPhysicalWidth"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getPhysicalHeight() const { + size_t output; + int temp; + glfwGetMonitorPhysicalSize(m_monitor, nullptr, &temp); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getPhysicalHeight"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Monitor::getContentScale(float* xscale, float* yscale) const { + glfwGetMonitorContentScale(m_monitor, xscale, yscale); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::getContentScale"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Monitor::getContentScale() const { + std::tuple output; + glfwGetMonitorContentScale(m_monitor, &std::get<0>(output), &std::get<1>(output)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getContentScale"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getContentScaleX() const { + float output; + glfwGetMonitorContentScale(m_monitor, &output, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getContentScaleX"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getContentScaleY() const { + float output; + glfwGetMonitorContentScale(m_monitor, nullptr, &output); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getContentScaleY"); + } + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getName() const { + char const* tmp = glfwGetMonitorName(m_monitor); + std::string_view output; + if (tmp) + output = tmp; +#else + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getName() const { + char const* output = glfwGetMonitorName(m_monitor); +#endif + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getName"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Monitor::setUserPointer( + void* pointer + ) const { + glfwSetMonitorUserPointer(m_monitor, pointer); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::setUserPointer"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getUserPointer() const { + void* output = glfwGetMonitorUserPointer(m_monitor); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getUserPointer"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getVideoMode( + ) const { + GLFWvidmode const* output = glfwGetVideoMode(m_monitor); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getVideoMode"); + } +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Monitor::getVideoModes() const { + int count; + GLFWvidmode const* pointer = glfwGetVideoModes(m_monitor, &count); + std::span output(pointer, static_cast(count)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getVideoModes"); + } +#else + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Monitor::getVideoModes( + ) const { + int count; + GLFWvidmode const* pointer = glfwGetVideoModes(m_monitor, &count); + std::vector output(pointer, pointer + static_cast(count)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getVideoModes"); + } +#endif + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Monitor::setGamma( + float gamma + ) const { + glfwSetGamma(m_monitor, gamma); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::setGamma"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Monitor::getGammaRamp( + ) const { + auto* output = glfwGetGammaRamp(m_monitor); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getGammaRamp"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Monitor::setGammaRamp( + GLFWgammaramp const* ramp + ) const { + glfwSetGammaRamp(m_monitor, ramp); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::setGammaRamp"); + } +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD VKFW_INLINE GLFWwindow* + createWindow(size_t width, size_t height, char const* title, GLFWmonitor* monitor, GLFWwindow* share) { + return glfwCreateWindow(static_cast(width), static_cast(height), title, monitor, share); + } + VKFW_NODISCARD VKFW_INLINE Result destroyWindow(GLFWwindow* window) { + glfwDestroyWindow(window); + return getError(); + } +#else +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS + VKFW_INLINE void setup_DynamicCallbackStorage(GLFWwindow* window_ptr) { + if (window_ptr) { + glfwSetWindowUserPointer(window_ptr, new DynamicCallbackStorage {}); + glfwSetWindowPosCallback(window_ptr, [](GLFWwindow* window, int xpos, int ypos) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_move) + ptr->on_window_move(window, xpos, ypos); + }); + glfwSetWindowSizeCallback(window_ptr, [](GLFWwindow* window, int width, int height) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_resize) + ptr->on_window_resize(window, static_cast(width), static_cast(height)); + }); + glfwSetWindowCloseCallback(window_ptr, [](GLFWwindow* window) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_close) + ptr->on_window_close(window); + }); + glfwSetWindowRefreshCallback(window_ptr, [](GLFWwindow* window) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_refresh) + ptr->on_window_refresh(window); + }); + glfwSetWindowFocusCallback(window_ptr, [](GLFWwindow* window, int focused) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_focus) + ptr->on_window_focus(window, static_cast(focused)); + }); + glfwSetWindowIconifyCallback(window_ptr, [](GLFWwindow* window, int iconified) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_iconify) + ptr->on_window_iconify(window, static_cast(iconified)); + }); + glfwSetWindowMaximizeCallback(window_ptr, [](GLFWwindow* window, int maximized) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_maximize) + ptr->on_window_maximize(window, static_cast(maximized)); + }); + glfwSetFramebufferSizeCallback(window_ptr, [](GLFWwindow* window, int width, int height) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_framebuffer_resize) + ptr->on_framebuffer_resize(window, static_cast(width), static_cast(height)); + }); + glfwSetWindowContentScaleCallback(window_ptr, [](GLFWwindow* window, float xscale, float yscale) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_window_content_scale_change) + ptr->on_window_content_scale_change(window, xscale, yscale); + }); + glfwSetMouseButtonCallback(window_ptr, [](GLFWwindow* window, int button, int action, int mods) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_mouse_button) + ptr->on_mouse_button( + window, + static_cast(button), + static_cast(action), + static_cast(mods) + ); + }); + glfwSetCursorPosCallback(window_ptr, [](GLFWwindow* window, double xpos, double ypos) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_cursor_move) + ptr->on_cursor_move(window, xpos, ypos); + }); + glfwSetCursorEnterCallback(window_ptr, [](GLFWwindow* window, int entered) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_cursor_enter) + ptr->on_cursor_enter(window, static_cast(entered)); + }); + glfwSetScrollCallback(window_ptr, [](GLFWwindow* window, double xoffset, double yoffset) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_scroll) + ptr->on_scroll(window, xoffset, yoffset); + }); + glfwSetKeyCallback(window_ptr, [](GLFWwindow* window, int key, int scancode, int action, int mods) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_key) + ptr->on_key( + window, + static_cast(key), + scancode, + static_cast(action), + static_cast(mods) + ); + }); + glfwSetCharCallback(window_ptr, [](GLFWwindow* window, unsigned int codepoint) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_character) + ptr->on_character(window, codepoint); + }); + glfwSetDropCallback(window_ptr, [](GLFWwindow* window, int path_count, char const* paths[]) { + auto* ptr = reinterpret_cast(glfwGetWindowUserPointer(window)); + if (ptr && ptr->on_drop) { +#ifdef VKFW_HAS_STRING_VIEW + std::vector output; + output.reserve(path_count); + std::transform(paths, paths + path_count, std::back_inserter(output), [](char const* path) { + return std::string_view { path }; + }); + ptr->on_drop(window, std::move(output)); +#else + ptr->on_drop(window, std::vector(paths, paths + path_count)); +#endif + } + }); + } + } +#endif + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type createWindow( + size_t width, + size_t height, + char const* title, + WindowHints hints, + Monitor monitor, + Window share, + bool reset_hints + ) { + Window output; + if (reset_hints) { + Result result = defaultWindowHints(); + if (!check(result)) + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::defaultWindowHints"); + } + Result result = setWindowHints(std::move(hints)); + if (!check(result)) + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::setWindowHints"); + + output = glfwCreateWindow(static_cast(width), static_cast(height), title, monitor, share); +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS + setup_DynamicCallbackStorage(output); +#endif + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::createWindow"); + } +#ifndef VKFW_NO_SMART_HANDLE + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type createWindowUnique( + size_t width, + size_t height, + char const* title, + WindowHints const& hints, + Monitor monitor, + Window share, + bool reset_hints + ) { + Window output; + if (reset_hints) { + Result result = defaultWindowHints(); + if (!check(result)) + return createResultValueUnique(result, output, VKFW_NAMESPACE_STRING "::defaultWindowHints"); + } + Result result = setWindowHints(hints); + if (!check(result)) + return createResultValueUnique(result, output, VKFW_NAMESPACE_STRING "::setWindowHints"); + + output = glfwCreateWindow(static_cast(width), static_cast(height), title, monitor, share); +#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS + setup_DynamicCallbackStorage(output); +#endif + return createResultValueUnique(getError(), output, VKFW_NAMESPACE_STRING "::createWindowUnique"); + } +#endif +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD VKFW_INLINE bool windowShouldClose(GLFWwindow* window) { + return static_cast(glfwWindowShouldClose(window)); + } + VKFW_INLINE void setWindowShouldClose(GLFWwindow* window, bool value) { + glfwSetWindowShouldClose(window, static_cast(value)); + } + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE std::string_view getWindowTitle(GLFWwindow* window) { + return glfwGetWindowTitle(window); + } + VKFW_INLINE void setWindowTitle(GLFWwindow* window, std::string_view title) { + glfwSetWindowTitle(window, title.data()); + } +#else + VKFW_NODISCARD VKFW_INLINE char const* getWindowTitle(GLFWwindow* window) { + return glfwGetWindowTitle(window); + } + VKFW_INLINE void setWindowTitle(GLFWwindow* window, char const* title) { + glfwSetWindowTitle(window, title); + } +#endif + + VKFW_INLINE void getWindowPos(GLFWwindow* window, int* xpos, int* ypos) { + glfwGetWindowPos(window, xpos, ypos); + } + VKFW_INLINE void setWindowPos(GLFWwindow* window, int xpos, int ypos) { + glfwSetWindowPos(window, xpos, ypos); + } + VKFW_INLINE void getWindowSize(GLFWwindow* window, size_t* width, size_t* height) { + int temp_width, temp_height; + glfwGetWindowSize(window, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *width = temp_width; + *height = temp_height; + } else { + *width = 0u; + *height = 0u; + } + } + VKFW_INLINE void setWindowSizeLimits( + GLFWwindow* window, + size_t minimum_width, + size_t minimum_height, + size_t maximum_width, + size_t maximum_height + ) { + glfwSetWindowSizeLimits( + window, + static_cast(minimum_width), + static_cast(minimum_height), + static_cast(maximum_width), + static_cast(maximum_height) + ); + } + VKFW_INLINE void setWindowAspectRatio(GLFWwindow* window, size_t numerator, size_t denominator) { + glfwSetWindowAspectRatio(window, static_cast(numerator), static_cast(denominator)); + } + VKFW_INLINE void setWindowSize(GLFWwindow* window, size_t width, size_t height) { + glfwSetWindowSize(window, static_cast(width), static_cast(height)); + } + VKFW_INLINE void getFramebufferSize(GLFWwindow* window, size_t* width, size_t* height) { + int temp_width, temp_height; + glfwGetFramebufferSize(window, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *width = temp_width; + *height = temp_height; + } else { + *width = 0u; + *height = 0u; + } + } + VKFW_INLINE void + getWindowFrameSize(GLFWwindow* window, size_t* left, size_t* top, size_t* right, size_t* bottom) { + int temp_left, temp_top, temp_right, temp_bottom; + glfwGetWindowFrameSize(window, &temp_left, &temp_top, &temp_right, &temp_bottom); + Result result = getError(); + if (check(result)) { + *left = temp_left; + *top = temp_top; + *right = temp_right; + *bottom = temp_bottom; + } else { + *left = 0u; + *top = 0u; + *right = 0u; + *bottom = 0u; + } + } + VKFW_INLINE void getWindowContentScale(GLFWwindow* window, float* xscale, float* yscale) { + glfwGetWindowContentScale(window, xscale, yscale); + } + VKFW_NODISCARD VKFW_INLINE float getWindowOpacity(GLFWwindow* window) { + return glfwGetWindowOpacity(window); + } + VKFW_INLINE void setWindowOpacity(GLFWwindow* window, float opacity) { + glfwSetWindowOpacity(window, opacity); + } + VKFW_INLINE void iconifyWindow(GLFWwindow* window) { glfwIconifyWindow(window); } + VKFW_INLINE void restoreWindow(GLFWwindow* window) { glfwRestoreWindow(window); } + VKFW_INLINE void maximizeWindow(GLFWwindow* window) { glfwMaximizeWindow(window); } + VKFW_INLINE void showWindow(GLFWwindow* window) { glfwShowWindow(window); } + VKFW_INLINE void hideWindow(GLFWwindow* window) { glfwHideWindow(window); } + VKFW_INLINE void focusWindow(GLFWwindow* window) { glfwFocusWindow(window); } + VKFW_INLINE void requestWindowAttention(GLFWwindow* window) { glfwRequestWindowAttention(window); } + VKFW_NODISCARD VKFW_INLINE GLFWmonitor* getWindowMonitor(GLFWwindow* window) { + return glfwGetWindowMonitor(window); + } + VKFW_INLINE void setWindowMonitor( + GLFWwindow* window, + GLFWmonitor* monitor, + int xpos, + int ypos, + size_t width, + size_t height, + size_t refreshRate + ) { + glfwSetWindowMonitor( + window, + monitor, + xpos, + ypos, + static_cast(width), + static_cast(height), + static_cast(refreshRate) + ); + } + +#ifdef VKFW_HAS_SPAN + VKFW_INLINE void setWindowIcon(GLFWwindow* window, std::span images) { + glfwSetWindowIcon(window, static_cast(images.size()), images.data()); + } +#endif + VKFW_INLINE void setWindowIcon(GLFWwindow* window, std::vector images) { + glfwSetWindowIcon(window, static_cast(images.size()), images.data()); + } + VKFW_INLINE void setWindowIcon(GLFWwindow* window, int image_count, vkfw::Image const* images) { + glfwSetWindowIcon(window, static_cast(image_count), images); + } + + template + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type>::type + getWindowAttribute(GLFWwindow* window) { + auto output = static_cast::type>( + glfwGetWindowAttrib(window, static_cast(attribute)) + ); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getWindowAttribute"); + } + template + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + setWindowAttribute(GLFWwindow* window, typename AttributeTraits::type const& new_value) { + glfwSetWindowAttrib(window, static_cast(attribute), static_cast(new_value)); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setWindowAttribute"); + } + + VKFW_NODISCARD VKFW_INLINE void* getWindowUserPointer(GLFWwindow* window) { +#ifdef VKFW_NO_STD_FUNCTION_CALLBACKS + return glfwGetWindowUserPointer(window); +#else + return accessWindowCallbacks(window)->user_ptr; +#endif + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + setWindowUserPointer(GLFWwindow* window, void* pointer) { +#ifdef VKFW_NO_STD_FUNCTION_CALLBACKS + glfwSetWindowUserPointer(m_window, ptr); +#else + accessWindowCallbacks(window)->user_ptr = pointer; +#endif + } + + VKFW_NODISCARD VKFW_INLINE bool getKey(GLFWwindow* window, Key key) { + return glfwGetKey(window, static_cast(key)) == static_cast(KeyAction::VKFW_ENUMERATOR(Press)); + } + VKFW_NODISCARD VKFW_INLINE bool getMouseButton(GLFWwindow* window, MouseButton button) { + return glfwGetKey(window, static_cast(button)) == + static_cast(MouseButtonAction::VKFW_ENUMERATOR(Press)); + } + VKFW_INLINE void getCursorPos(GLFWwindow* window, double* xpos, double* ypos) { + glfwGetCursorPos(window, xpos, ypos); + } + VKFW_INLINE void setCursorPos(GLFWwindow* window, double xpos, double ypos) { + glfwSetCursorPos(window, xpos, ypos); + } + + VKFW_INLINE void setCursor(GLFWwindow* window, GLFWcursor* cursor) { glfwSetCursor(window, cursor); } +#else + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::shouldClose() const { + auto output = static_cast(glfwWindowShouldClose(m_window)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::shouldClose"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setShouldClose( + bool value + ) const { + glfwSetWindowShouldClose(m_window, value); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setShouldClose"); + } + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE std::string_view Window::getTitle() const { + return glfwGetWindowTitle(m_window); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setTitle( + std::string_view title + ) const { + glfwSetWindowTitle(m_window, title.data()); +#else + VKFW_NODISCARD VKFW_INLINE char const* Window::getTitle() const { return glfwGetWindowTitle(m_window); } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setTitle( + char const* title + ) const { + glfwSetWindowTitle(m_window, title); +#endif + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setTitle"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::getPos(int* xpos, int* ypos) const { + glfwGetWindowPos(m_window, xpos, ypos); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::getPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Window::getPos() const { + std::tuple output; + glfwGetWindowPos(m_window, &std::get<0>(output), &std::get<1>(output)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getPosX() const { + int output; + glfwGetWindowPos(m_window, &output, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getPosX"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getPosY() const { + int output; + glfwGetWindowPos(m_window, nullptr, &output); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getPosY"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::setPos(int xpos, int ypos) const { + glfwSetWindowPos(m_window, xpos, ypos); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setPos"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setPos( + std::tuple pos + ) const { + glfwSetWindowPos(m_window, std::get<0>(pos), std::get<1>(pos)); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setPos"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::getSize(size_t* width, size_t* height) const { + int temp_width, temp_height; + glfwGetWindowSize(m_window, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *width = temp_width; + *height = temp_height; + } else { + *width = 0u; + *height = 0u; + } + return createResultValue(result, VKFW_NAMESPACE_STRING "::Window::getSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Window::getSize( + ) const { + std::tuple output; + int temp_width, temp_height; + glfwGetWindowSize(m_window, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + std::get<0>(output) = temp_width; + std::get<1>(output) = temp_height; + } else { + std::get<0>(output) = 0u; + std::get<1>(output) = 0u; + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getWidth() const { + size_t output; + int temp; + glfwGetWindowSize(m_window, &temp, nullptr); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getWidth"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getHeight() const { + size_t output; + int temp; + glfwGetWindowSize(m_window, nullptr, &temp); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getHeight"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::setSize(size_t width, size_t height) const { + glfwSetWindowSize(m_window, static_cast(width), static_cast(height)); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSize"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setSize( + std::tuple size + ) const { + glfwSetWindowSize(m_window, static_cast(std::get<0>(size)), static_cast(std::get<1>(size))); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSize"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setSizeLimits( + size_t minimum_width, + size_t minimum_height, + size_t maximum_width, + size_t maximum_height + ) const { + glfwSetWindowSizeLimits( + m_window, + static_cast(minimum_width), + static_cast(minimum_height), + static_cast(maximum_width), + static_cast(maximum_height) + ); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSizeLimits"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setSizeLimits( + std::tuple minimum_size, + std::tuple maximum_size + ) const { + glfwSetWindowSizeLimits( + m_window, + static_cast(std::get<0>(minimum_size)), + static_cast(std::get<1>(minimum_size)), + static_cast(std::get<0>(maximum_size)), + static_cast(std::get<1>(maximum_size)) + ); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSizeLimits"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setSizeLimits( + std::tuple limits + ) const { + glfwSetWindowSizeLimits( + m_window, + static_cast(std::get<0>(limits)), + static_cast(std::get<1>(limits)), + static_cast(std::get<2>(limits)), + static_cast(std::get<3>(limits)) + ); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSizeLimits"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::setAspectRatio(size_t numerator, size_t denominator) const { + glfwSetWindowAspectRatio(m_window, static_cast(numerator), static_cast(denominator)); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setAspectRatio"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::getFramebufferSize(size_t* width, size_t* height) const { + int temp_width, temp_height; + glfwGetFramebufferSize(m_window, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + *width = temp_width; + *height = temp_height; + } else { + *width = 0u; + *height = 0u; + } + return createResultValue(result, VKFW_NAMESPACE_STRING "::Window::getFramebufferSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Window::getFramebufferSize() const { + std::tuple output; + int temp_width, temp_height; + glfwGetFramebufferSize(m_window, &temp_width, &temp_height); + Result result = getError(); + if (check(result)) { + std::get<0>(output) = temp_width; + std::get<1>(output) = temp_height; + } else { + std::get<0>(output) = 0u; + std::get<1>(output) = 0u; + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getFramebufferSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getFramebufferWidth() const { + size_t output; + int temp; + glfwGetFramebufferSize(m_window, &temp, nullptr); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getFramebufferWidth"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getFramebufferHeight() const { + size_t output; + int temp; + glfwGetFramebufferSize(m_window, nullptr, &temp); + Result result = getError(); + if (check(result)) + output = static_cast(temp); + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getFramebufferHeight"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::getFrameSize(size_t* left, size_t* top, size_t* right, size_t* bottom) const { + int temp_left, temp_top, temp_right, temp_bottom; + glfwGetWindowFrameSize(m_window, &temp_left, &temp_top, &temp_right, &temp_bottom); + Result result = getError(); + if (check(result)) { + *left = temp_left; + *top = temp_top; + *right = temp_right; + *bottom = temp_bottom; + } else { + *left = 0u; + *top = 0u; + *right = 0u; + *bottom = 0u; + } + return createResultValue(result, VKFW_NAMESPACE_STRING "::Window::getFrameSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type + Window::getFrameSize() const { + std::tuple output; + int temp_left, temp_top, temp_right, temp_bottom; + glfwGetWindowFrameSize(m_window, &temp_left, &temp_top, &temp_right, &temp_bottom); + Result result = getError(); + if (check(result)) { + std::get<0>(output) = temp_left; + std::get<1>(output) = temp_top; + std::get<2>(output) = temp_right; + std::get<3>(output) = temp_bottom; + } else { + std::get<0>(output) = 0u; + std::get<1>(output) = 0u; + std::get<2>(output) = 0u; + std::get<3>(output) = 0u; + } + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getFrameSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getLeftFrameSize() const { + size_t output; + int temp; + glfwGetWindowFrameSize(m_window, &temp, nullptr, nullptr, nullptr); + Result result = getError(); + if (check(result)) + output = temp; + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getLeftFrameSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getTopFrameSize() const { + size_t output; + int temp; + glfwGetWindowFrameSize(m_window, nullptr, &temp, nullptr, nullptr); + Result result = getError(); + if (check(result)) + output = temp; + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getTopFrameSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getRightFrameSize() const { + size_t output; + int temp; + glfwGetWindowFrameSize(m_window, nullptr, nullptr, &temp, nullptr); + Result result = getError(); + if (check(result)) + output = temp; + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getRightFrameSize"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getBottomFrameSize() const { + size_t output; + int temp; + glfwGetWindowFrameSize(m_window, nullptr, nullptr, nullptr, &temp); + Result result = getError(); + if (check(result)) + output = temp; + else + output = 0u; + return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getBottomFrameSize"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::getContentScale(float* xscale, float* yscale) const { + glfwGetWindowContentScale(m_window, xscale, yscale); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::getContentScale"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Window::getContentScale( + ) const { + std::tuple output; + glfwGetWindowContentScale(m_window, &std::get<0>(output), &std::get<1>(output)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getContentScale"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getContentScaleX() const { + float output; + glfwGetWindowContentScale(m_window, &output, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getContentScaleX"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getContentScaleY() const { + float output; + glfwGetWindowContentScale(m_window, nullptr, &output); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getContentScaleY"); + } + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getOpacity() const { + auto output = glfwGetWindowOpacity(m_window); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getOpacity"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setOpacity( + float opacity + ) const { + glfwSetWindowOpacity(m_window, opacity); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setOpacity"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::iconify() const { + glfwIconifyWindow(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::iconify"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::restore() const { + glfwRestoreWindow(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::restore"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::maximize( + ) const { + glfwMaximizeWindow(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::maximize"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::show() const { + glfwShowWindow(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::show"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::hide() const { + glfwHideWindow(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::hide"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::focus() const { + glfwFocusWindow(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::focus"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::requestAttention( + ) const { + glfwRequestWindowAttention(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::requestAttention"); + } + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getMonitor() const { + Monitor output = glfwGetWindowMonitor(m_window); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getMonitor"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setMonitor( + Monitor const& monitor, + int xpos, + int ypos, + size_t width, + size_t height, + size_t refreshRate + ) const { + glfwSetWindowMonitor( + m_window, + monitor, + xpos, + ypos, + static_cast(width), + static_cast(height), + static_cast(refreshRate) + ); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setMonitor"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setMonitor( + Monitor const& monitor, + std::tuple pos, + std::tuple size, + size_t refreshRate + ) const { + glfwSetWindowMonitor( + m_window, + monitor, + std::get<0>(pos), + std::get<1>(pos), + static_cast(std::get<0>(size)), + static_cast(std::get<1>(size)), + static_cast(refreshRate) + ); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setMonitor"); + } + + template + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type>::type + Window::get() const { + auto output = static_cast::type>( + glfwGetWindowAttrib(m_window, static_cast(attribute)) + ); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::get"); + } + template + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::set( + typename AttributeTraits::type const& new_value + ) const { + glfwSetWindowAttrib(m_window, static_cast(attribute), static_cast(new_value)); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::set"); + } + + template + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type>::type Window::get( + ) const { + auto output = + static_cast::type>(glfwGetInputMode(m_window, static_cast(mode))); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::get"); + } + + template + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::set( + typename InputModeTraits::type const& new_value + ) const { + glfwSetInputMode(m_window, static_cast(mode), static_cast(new_value)); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::set"); + } + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getUserPointer() const { +#ifdef VKFW_NO_STD_FUNCTION_CALLBACKS + auto* output = glfwGetWindowUserPointer(m_window); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getUserPointer"); +#else + auto* output = callbacks()->user_ptr; + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getUserPointer"); +#endif + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setUserPointer( + void* pointer + ) const { +#ifdef VKFW_NO_STD_FUNCTION_CALLBACKS + glfwSetWindowUserPointer(m_window, pointer); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setUserPointer"); +#else + callbacks()->user_ptr = pointer; + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setUserPointer"); +#endif + } + +#ifdef VKFW_HAS_SPAN + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setIcon( + std::span images + ) const { + glfwSetWindowIcon(m_window, static_cast(images.size()), images.data()); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setIcon"); + } +#endif + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setIcon( + std::vector images + ) const { + glfwSetWindowIcon(m_window, static_cast(images.size()), images.data()); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setIcon"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::setIcon(size_t image_count, vkfw::Image* images) const { + glfwSetWindowIcon(m_window, static_cast(image_count), images); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setIcon"); + } + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getKey(Key key) const { + bool output = + glfwGetKey(m_window, static_cast(key)) == static_cast(KeyAction::VKFW_ENUMERATOR(Press)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getKey"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getMouseButton(MouseButton button + ) const { + bool output = glfwGetMouseButton(m_window, static_cast(button)) == + static_cast(MouseButtonAction::VKFW_ENUMERATOR(Press)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getMouseButton"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::getCursorPos(double* xpos, double* ypos) const { + glfwGetCursorPos(m_window, xpos, ypos); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::getCursorPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType>::type Window::getCursorPos( + ) const { + std::tuple output; + glfwGetCursorPos(m_window, &std::get<0>(output), &std::get<1>(output)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getCursorPos"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getCursorPosX() const { + double output; + glfwGetCursorPos(m_window, &output, nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getCursorPosX"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type Window::getCursorPosY() const { + double output; + glfwGetCursorPos(m_window, nullptr, &output); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getCursorPosY"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::setCursorPos(double xpos, double ypos) const { + glfwSetCursorPos(m_window, xpos, ypos); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setCursorPos"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::setCursor( + Cursor const& cursor + ) const { + glfwSetCursor(m_window, cursor); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setCursorPos"); + } + + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type + Window::makeContextCurrent() const { + glfwMakeContextCurrent(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::makeContextCurrent"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type Window::swapBuffers( + ) const { + glfwSwapBuffers(m_window); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::swapBuffers"); + } +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_INLINE void pollEvents() { glfwPollEvents(); } + VKFW_INLINE void waitEvents() { glfwWaitEvents(); } + VKFW_INLINE void waitEventsTimeout(double timeout) { glfwWaitEventsTimeout(timeout); } + VKFW_INLINE void postEmptyEvent() { glfwPostEmptyEvent(); } + + VKFW_INLINE void makeContextCurrent(GLFWwindow* window) { glfwMakeContextCurrent(window); } + VKFW_NODISCARD VKFW_INLINE GLFWwindow* getCurrentContext() { return glfwGetCurrentContext(); } + VKFW_INLINE void swapBuffers(GLFWwindow* window) { glfwSwapBuffers(window); } + VKFW_INLINE void swapInterval(int interval) { glfwSwapInterval(interval); } + + VKFW_NODISCARD VKFW_INLINE bool rawMouseMotionSupported() { + return static_cast(glfwRawMouseMotionSupported()); + } + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE std::string_view getKeyName(Key key, int scancode) { + char const* tmp = glfwGetKeyName(static_cast(key), scancode); + return tmp ? std::string_view(tmp) : std::string_view(); + } +#else + VKFW_NODISCARD VKFW_INLINE char const* getKeyName(Key key, int scancode) { + return glfwGetKeyName(static_cast(key), scancode); + } +#endif + VKFW_NODISCARD VKFW_INLINE int getKeyScancode(Key key) { return glfwGetKeyScancode(static_cast(key)); } +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type pollEvents() { + glfwPollEvents(); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::pollEvents"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type waitEvents() { + glfwWaitEvents(); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::waitEvents"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type waitEventsTimeout( + double timeout + ) { + glfwWaitEventsTimeout(timeout); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::waitEventsTimeout"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type waitEventsTimeout( + std::chrono::duration timeout + ) { + glfwWaitEventsTimeout(timeout.count()); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::waitEventsTimeout"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type postEmptyEvent() { + glfwPostEmptyEvent(); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::postEmptyEvent"); + } + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getCurrentContext() { + Window output = glfwGetCurrentContext(); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getCurrentContext"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type swapInterval(int interval + ) { + glfwSwapInterval(interval); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::swapInterval"); + } + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type rawMouseMotionSupported() { + bool output = static_cast(glfwRawMouseMotionSupported()); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::rawMouseMotionSupported"); + } + +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type + getKeyName(Key key, int32_t scancode) { + char const* tmp = glfwGetKeyName(static_cast(key), static_cast(scancode)); + std::string_view output; + if (tmp) + output = tmp; +#else + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type + getKeyName(Key key, int32_t scancode) { + char const* output = glfwGetKeyName(static_cast(key), static_cast(scancode)); +#endif + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::rawMouseMotionSupported"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getKeyScancode(Key key) { + int32_t output = static_cast(glfwGetKeyScancode(static_cast(key))); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::rawMouseMotionSupported"); + } +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE + VKFW_NODISCARD VKFW_INLINE GLFWcursor* createCursor(vkfw::Image const* image, int xhot, int yhot) { + return glfwCreateCursor(image, xhot, yhot); + } + VKFW_NODISCARD VKFW_INLINE GLFWcursor* createStandardCursor(CursorShape shape) { + return glfwCreateStandardCursor(static_cast(shape)); + } + VKFW_NODISCARD VKFW_INLINE Result destroyCursor(GLFWcursor* cursor) { + glfwDestroyCursor(cursor); + return getError(); + } +#else + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type + createCursor(vkfw::Image const& image, int xhot, int yhot) { + Cursor output = glfwCreateCursor(&image, xhot, yhot); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::createCursor"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type createStandardCursor(CursorShape shape) { + Cursor output = glfwCreateStandardCursor(static_cast(shape)); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::createStandardCursor"); + } +#ifndef VKFW_NO_SMART_HANDLE + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type + createCursorUnique(vkfw::Image const& image, int xhot, int yhot) { + Cursor output = glfwCreateCursor(&image, xhot, yhot); + return createResultValueUnique(getError(), output, VKFW_NAMESPACE_STRING "::createCursorUnique"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type createStandardCursorUnique( + CursorShape shape + ) { + Cursor output = glfwCreateStandardCursor(static_cast(shape)); + return createResultValueUnique(getError(), output, VKFW_NAMESPACE_STRING "::createStandardCursorUnique"); + } +#endif +#endif + +#ifdef VKFW_DISABLE_ENHANCED_MODE +#ifdef VKFW_HAS_STRING_VIEW + VKFW_INLINE void setClipboardString(std::string_view string) { + glfwSetClipboardString(nullptr, string.data()); + } + VKFW_INLINE std::string_view getClipboardString() { + char const* tmp = glfwGetClipboardString(nullptr); + return tmp ? std::string_view(tmp) : std::string_view(); + } +#else + VKFW_INLINE void setClipboardString(char const* string) { glfwSetClipboardString(nullptr, string); } + VKFW_INLINE char const* getClipboardString() { return glfwGetClipboardString(nullptr); } +#endif + + VKFW_INLINE double getTime() { return glfwGetTime(); } + VKFW_INLINE void setTime(double time) { glfwSetTime(time); } + VKFW_INLINE uint64_t getTimerValue() { return glfwGetTimerValue(); } + VKFW_INLINE uint64_t getTimerFrequency() { return glfwGetTimerFrequency(); } +#else +#ifdef VKFW_HAS_STRING_VIEW + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type setClipboardString( + std::string_view string + ) { + glfwSetClipboardString(nullptr, string.data()); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setClipboardString"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getClipboardString() { + char const* tmp = glfwGetClipboardString(nullptr); + std::string_view output; + if (tmp) + output = tmp; + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getClipboardString"); + } +#else + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type setClipboardString( + char const* string + ) { + glfwSetClipboardString(nullptr, string); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setClipboardString"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getClipboardString() { + char const* output = glfwGetClipboardString(nullptr); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getClipboardString"); + } +#endif + + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getTime() { + double output = glfwGetTime(); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getTime"); + } + VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType::type setTime(double time) { + glfwSetTime(time); + return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setTime"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getTimerValue() { + uint64_t output = glfwGetTimerValue(); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getTimerValue"); + } + VKFW_NODISCARD VKFW_INLINE typename ResultValueType::type getTimerFrequency() { + uint64_t output = glfwGetTimerFrequency(); + return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getTimerFrequency"); + } +#endif +} // namespace VKFW_NAMESPACE