avery/vulkan-test
1
0
Fork 0
forked from pupbrained/vulkan-test
Code Pull requests Activity
vulkan-test/include/vkfw.hpp

5016 lines
210 KiB
C++
Raw Blame History

#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(<version> )
#include <version>
#endif
#if !defined(VKFW_NO_STRING_VIEW) && 17 <= VKFW_CPP_VERSION
#include <string_view>
#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(<span> )
#include <span>
#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(<compare> )
#define VKFW_HAS_SPACESHIP_OPERATOR
#include <compare>
#endif
#include <cstdint>
#include <string>
#include <system_error>
#include <tuple>
#include <vector>
#ifndef VKFW_INCLUDE_GL
#define GLFW_INCLUDE_NONE
#endif
#ifndef VKFW_NO_INCLUDE_VULKAN
#define GLFW_INCLUDE_VULKAN
#endif
#include <GLFW/glfw3.h>
#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 <vulkan/vulkan.hpp>
#endif
#ifdef VKFW_DISABLE_ENHANCED_MODE
#ifndef VKFW_NO_SMART_HANDLE
#define VKFW_NO_SMART_HANDLE
#endif
#else
#include <algorithm>
#include <chrono>
#include <iterator>
#include <memory>
#endif
#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS
#include <functional>
#endif
#ifndef VKFW_ASSERT
#include <cassert>
#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<ModifierKeyBits>::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<MaskType>(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<MaskType>(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 <typename BitType>
VKFW_CONSTEXPR bool operator<(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT {
return flags > bit;
}
template <typename BitType>
VKFW_CONSTEXPR bool operator<=(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT {
return flags >= bit;
}
template <typename BitType>
VKFW_CONSTEXPR bool operator>(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT {
return flags < bit;
}
template <typename BitType>
VKFW_CONSTEXPR bool operator>=(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT {
return flags <= bit;
}
template <typename BitType>
VKFW_CONSTEXPR bool operator==(BitType bit, ModifierKeyFlags const& flags) VKFW_NOEXCEPT {
return flags == bit;
}
template <typename BitType>
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 <InitializationHint hint>
struct InitializationHintTraits;
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(Platform)> {
using type = Platform;
};
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(AnglePlatformType)> {
using type = AnglePlatformType;
};
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(JoystickHatButtons)> {
using type = bool;
};
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(CocoaChdirResources)> {
using type = bool;
};
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(CocoaMenubar)> {
using type = bool;
};
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(WaylandLibDecor)> {
using type = WaylandLibDecor;
};
template <>
struct InitializationHintTraits<InitializationHint::VKFW_ENUMERATOR(X11XCBVulkanSurface)> {
using type = bool;
};
template <WindowHint hint>
struct WindowHintTraits;
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Focused)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Resizable)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Visible)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Decorated)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AutoIconify)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Floating)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Maximized)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(CenterCursor)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(TransparentFramebuffer)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(FocusOnShow)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(MousePassthrough)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(PositionX)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(PositionY)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(RedBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(GreenBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(BlueBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AlphaBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(DepthBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(StencilBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AccumulationRedBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AccumulationGreenBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AccumulationBlueBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AccumulationAlphaBits)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(AuxiliaryBuffers)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(StereoscopicRendering)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Samples)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(SRGBCapable)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(RefreshRate)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ScaleToMonitor)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ScaleFramebuffer)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(DoubleBuffer)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ClientAPI)> {
using type = ClientAPI;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ContextVersionMajor)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ContextVersionMinor)> {
using type = unsigned;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ContextRobustness)> {
using type = ContextRobustness;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(OpenGLForwardCompatibility)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(OpenGLDebugContext)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(OpenGLProfile)> {
using type = OpenGLProfile;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ContextReleaseBehavior)> {
using type = ContextReleaseBehavior;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ContextNoError)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(ContextCreationAPI)> {
using type = ContextCreationAPI;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Win32KeyboardMenu)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(Win32ShowDefault)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(CocoaRetinaFramebuffer)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)> {
#ifdef VKFW_HAS_STRING_VIEW
using type = std::string_view;
#else
using type = char const*;
#endif
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(CocoaGraphicsSwitching)> {
using type = bool;
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(X11ClassName)> {
#ifdef VKFW_HAS_STRING_VIEW
using type = std::string_view;
#else
using type = char const*;
#endif
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(X11InstanceName)> {
#ifdef VKFW_HAS_STRING_VIEW
using type = std::string_view;
#else
using type = char const*;
#endif
};
template <>
struct WindowHintTraits<WindowHint::VKFW_ENUMERATOR(WaylandAppID)> {
#ifdef VKFW_HAS_STRING_VIEW
using type = std::string_view;
#else
using type = char const*;
#endif
};
template <Attribute attribute>
struct AttributeTraits;
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Focused)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Iconified)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Resizable)> : std::true_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Visible)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Decorated)> : std::true_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(AutoIconify)> : std::true_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Floating)> : std::true_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Maximized)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(TransparentFramebuffer)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(Hovered)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(FocusOnShow)> : std::true_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(MousePassthrough)> : std::true_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ClientAPI)> : std::false_type {
using type = ClientAPI;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextVersionMajor)> : std::false_type {
using type = size_t;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextVersionMinor)> : std::false_type {
using type = size_t;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextRevision)> : std::false_type {
using type = size_t;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextRobustness)> : std::false_type {
using type = ContextRobustness;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(OpenGLForwardCompatibility)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(OpenGLDebugContext)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(OpenGLProfile)> : std::false_type {
using type = OpenGLProfile;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextReleaseBehavior)> : std::false_type {
using type = ContextReleaseBehavior;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextNoError)> : std::false_type {
using type = bool;
};
template <>
struct AttributeTraits<Attribute::VKFW_ENUMERATOR(ContextCreationAPI)> : std::false_type {
using type = ContextCreationAPI;
};
template <InputMode mode>
struct InputModeTraits;
template <>
struct InputModeTraits<InputMode::VKFW_ENUMERATOR(Cursor)> {
using type = CursorMode;
};
template <>
struct InputModeTraits<InputMode::VKFW_ENUMERATOR(StickyKeys)> {
using type = bool;
};
template <>
struct InputModeTraits<InputMode::VKFW_ENUMERATOR(StickyMouseButtons)> {
using type = bool;
};
template <>
struct InputModeTraits<InputMode::VKFW_ENUMERATOR(LockKeyModifiers)> {
using type = bool;
};
template <>
struct InputModeTraits<InputMode::VKFW_ENUMERATOR(RawMouseMotion)> {
using type = bool;
};
#endif
} // namespace VKFW_NAMESPACE
namespace VKFW_NAMESPACE {
#ifndef VKFW_NO_SMART_HANDLE
#ifndef VKFW_NO_INCLUDE_VULKAN_HPP
template <typename Type>
using UniqueHandleTraits =
VULKAN_HPP_NAMESPACE::UniqueHandleTraits<Type, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
template <typename Type>
using UniqueHandle = VULKAN_HPP_NAMESPACE::UniqueHandle<Type, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE>;
#else
template <typename Type>
class UniqueHandleTraits;
template <typename Type>
class UniqueHandle : public UniqueHandleTraits<Type>::deleter {
private:
using Deleter = typename UniqueHandleTraits<Type>::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<Deleter&>(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<Deleter*>(this) = std::move(static_cast<Deleter&>(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<Type>& rhs) VKFW_NOEXCEPT {
std::swap(m_value, rhs.m_value);
std::swap(static_cast<Deleter&>(*this), static_cast<Deleter&>(rhs));
}
private:
Type m_value;
};
#endif
#endif
} // namespace VKFW_NAMESPACE
#ifndef VKFW_NO_EXCEPTIONS
namespace std {
template <>
struct is_error_code_enum<VKFW_NAMESPACE::Result> : 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<Result>(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<int>(e), errorCategory());
}
VKFW_INLINE std::error_condition make_error_condition(Result e) VKFW_NOEXCEPT {
return std::error_condition(static_cast<int>(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 <typename T>
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<Result&, T&>() VKFW_NOEXCEPT { return std::tuple<Result&, T&>(result, value); }
};
#ifndef VKFW_NO_SMART_HANDLE
template <typename Type>
struct ResultValue<UniqueHandle<Type>> {
#ifdef VKFW_HAS_NOEXCEPT
ResultValue(Result r, UniqueHandle<Type>&& v) VKFW_NOEXCEPT
#else
ResultValue(Result r, UniqueHandle<Type>&& v)
#endif
: result(r),
value(std::move(v)) {
}
std::tuple<Result, UniqueHandle<Type>> asTuple() { return std::make_tuple(result, std::move(value)); }
Result result;
UniqueHandle<Type> value;
};
#endif
template <typename T>
struct ResultValueType {
#ifdef VKFW_NO_EXCEPTIONS
typedef ResultValue<T> type;
#else
typedef T type;
#endif
};
template <>
struct ResultValueType<void> {
#ifdef VKFW_NO_EXCEPTIONS
typedef Result type;
#else
typedef void type;
#endif
};
template <typename T>
VKFW_INLINE void ignore(T const&) VKFW_NOEXCEPT {}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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 <typename T>
VKFW_INLINE typename ResultValueType<T>::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<T>(result, std::move(data));
#else
if (!check(result))
throwResultException(result, message);
return std::move(data);
#endif
}
#ifndef VKFW_NO_SMART_HANDLE
template <typename T>
VKFW_INLINE typename ResultValueType<UniqueHandle<T>>::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<UniqueHandle<T>>(result, UniqueHandle<T>(data));
#else
if (!check(result))
throwResultException(result, message);
return UniqueHandle<T>(data);
#endif
}
#endif
#ifndef VKFW_NO_SMART_HANDLE
template <typename T>
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 <typename T>
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<std::is_convertible<convertible_value_type, value_type>::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<std::is_convertible<convertible_value_type, value_type>::value>::type>
VKFW_INLINE VKFW_CONSTEXPR Optional(convertible_value_type&& value)
: m_has_value(true), m_value(value_type { std::move(value) }) {}
template <class U>
VKFW_INLINE VKFW_CONSTEXPR Optional(Optional<U> const& another)
: m_has_value(another.m_has_value), m_value(another.m_value) {}
template <class U>
VKFW_INLINE VKFW_CONSTEXPR Optional(Optional<U>&& 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 <class U>
VKFW_INLINE VKFW_CONSTEXPR_14 Optional& operator=(Optional<U> const& another) {
m_has_value = another.m_has_value;
m_value = another.m_value;
return *this;
}
template <class U>
VKFW_INLINE VKFW_CONSTEXPR_14 Optional& operator=(Optional<U>&& 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<void>::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<void>::type getPos(int* xpos, int* ypos) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<int, int>>::type getPos() const;
VKFW_NODISCARD typename ResultValueType<int>::type getPosX() const;
VKFW_NODISCARD typename ResultValueType<int>::type getPosY() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getWorkarea(int* xpos, int* ypos, size_t* width, size_t* height) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<int, int, size_t, size_t>>::type getWorkarea() const;
VKFW_NODISCARD typename ResultValueType<std::tuple<int, int>>::type getWorkareaPos() const;
VKFW_NODISCARD typename ResultValueType<int>::type getWorkareaPosX() const;
VKFW_NODISCARD typename ResultValueType<int>::type getWorkareaPosY() const;
VKFW_NODISCARD typename ResultValueType<std::tuple<size_t, size_t>>::type getWorkareaSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getWorkareaWidth() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getWorkareaHeight() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getPhysicalSize(size_t* widthMM, size_t* heightMM) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<size_t, size_t>>::type getPhysicalSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getPhysicalWidth() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getPhysicalHeight() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getContentScale(float* xscale, float* yscale) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<float, float>>::type getContentScale() const;
VKFW_NODISCARD typename ResultValueType<float>::type getContentScaleX() const;
VKFW_NODISCARD typename ResultValueType<float>::type getContentScaleY() const;
#ifdef VKFW_HAS_STRING_VIEW
VKFW_NODISCARD typename ResultValueType<std::string_view>::type getName() const;
#else
VKFW_NODISCARD typename ResultValueType<char const*>::type getName() const;
#endif
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setUserPointer(void* pointer
) const;
VKFW_NODISCARD typename ResultValueType<void*>::type getUserPointer() const;
VKFW_NODISCARD typename ResultValueType<GLFWvidmode const*>::type getVideoMode() const;
#ifdef VKFW_HAS_SPAN
VKFW_NODISCARD typename ResultValueType<std::span<GLFWvidmode const>>::type getVideoModes() const;
#else
VKFW_NODISCARD typename ResultValueType<std::vector<GLFWvidmode>>::type getVideoModes() const;
#endif
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setGamma(float gamma) const;
VKFW_NODISCARD typename ResultValueType<GLFWgammaramp const*>::type getGammaRamp() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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<void>::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<void>::type destroy();
VKFW_NODISCARD typename ResultValueType<bool>::type shouldClose() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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<void>::type setTitle(std::string_view title
) const;
#else
VKFW_NODISCARD VKFW_INLINE char const* getTitle() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setTitle(char const* title) const;
#endif
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type getPos(int* xpos, int* ypos) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<int, int>>::type getPos() const;
VKFW_NODISCARD typename ResultValueType<int>::type getPosX() const;
VKFW_NODISCARD typename ResultValueType<int>::type getPosY() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPos(int xpos, int ypos) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setPos(std::tuple<int, int> pos
) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getSize(size_t* width, size_t* height) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<size_t, size_t>>::type getSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getWidth() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getHeight() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setSize(size_t width, size_t height) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setSize(
std::tuple<size_t, size_t> size
) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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<void>::type
setSizeLimits(std::tuple<size_t, size_t> minimum_size, std::tuple<size_t, size_t> maximum_size) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setSizeLimits(
std::tuple<size_t, size_t, size_t, size_t> limits
) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setAspectRatio(size_t numerator, size_t denominator) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getFramebufferSize(size_t* width, size_t* height) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<size_t, size_t>>::type getFramebufferSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getFramebufferWidth() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getFramebufferHeight() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getFrameSize(size_t* left, size_t* top, size_t* right, size_t* bottom) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<size_t, size_t, size_t, size_t>>::type getFrameSize(
) const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getLeftFrameSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getTopFrameSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getRightFrameSize() const;
VKFW_NODISCARD typename ResultValueType<size_t>::type getBottomFrameSize() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getContentScale(float* xscale, float* yscale) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<float, float>>::type getContentScale() const;
VKFW_NODISCARD typename ResultValueType<float>::type getContentScaleX() const;
VKFW_NODISCARD typename ResultValueType<float>::type getContentScaleY() const;
VKFW_NODISCARD typename ResultValueType<float>::type getOpacity() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setOpacity(float opacity) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type iconify() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type restore() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type maximize() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type show() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type hide() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type focus() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type requestAttention() const;
VKFW_NODISCARD typename ResultValueType<Monitor>::type getMonitor() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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<void>::type setMonitor(
Monitor const& monitor,
std::tuple<int, int> pos,
std::tuple<size_t, size_t> size,
size_t refreshRate = 0
) const;
#ifdef VKFW_HAS_SPAN
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setIcon(
std::span<vkfw::Image> images
) const;
#endif
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setIcon(
std::vector<vkfw::Image> images
) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setIcon(size_t image_count, vkfw::Image* images) const;
template <Attribute attribute>
VKFW_NODISCARD typename ResultValueType<typename AttributeTraits<attribute>::type>::type get() const;
template <
Attribute attribute,
typename = typename std::enable_if<AttributeTraits<attribute>::value>::type>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type set(
typename AttributeTraits<attribute>::type const& new_value
) const;
template <InputMode mode>
VKFW_NODISCARD typename ResultValueType<typename InputModeTraits<mode>::type>::type get() const;
template <InputMode mode>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type set(
typename InputModeTraits<mode>::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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(m_window));
}
#endif
VKFW_NODISCARD typename ResultValueType<void*>::type getUserPointer() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setUserPointer(void* pointer
) const;
VKFW_NODISCARD typename ResultValueType<bool>::type getKey(Key key) const;
VKFW_NODISCARD typename ResultValueType<bool>::type getMouseButton(MouseButton button) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
getCursorPos(double* xpos, double* ypos) const;
VKFW_NODISCARD typename ResultValueType<std::tuple<double, double>>::type getCursorPos() const;
VKFW_NODISCARD typename ResultValueType<double>::type getCursorPosX() const;
VKFW_NODISCARD typename ResultValueType<double>::type getCursorPosY() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setCursorPos(double xpos, double ypos) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setCursor(Cursor const& cursor
) const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type makeContextCurrent() const;
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type swapBuffers() const;
private:
GLFWwindow* m_window;
};
#endif
VKFW_INLINE Result getError(char const** description = nullptr) {
return static_cast<Result>(glfwGetError(description));
}
VKFW_INLINE GLFWerrorfun setErrorCallback(GLFWerrorfun callback) { return glfwSetErrorCallback(callback); }
VKFW_NODISCARD VKFW_INLINE Platform getPlatform() { return static_cast<Platform>(glfwGetPlatform()); }
VKFW_NODISCARD VKFW_INLINE bool platformSupported(Platform platform) {
return glfwPlatformSupported(static_cast<int>(platform)) == GLFW_TRUE;
}
template <InitializationHint hint>
VKFW_INLINE Result initHint(typename InitializationHintTraits<hint>::type value) {
glfwInitHint(static_cast<int>(hint), static_cast<int>(value));
return getError();
}
#ifndef VKFW_DISABLE_ENHANCED_MODE
template <InitializationHint hint>
class OptionalInitializationHint : public Optional<typename InitializationHintTraits<hint>::type> {
public:
using Optional<typename InitializationHintTraits<hint>::type>::Optional;
};
struct InitHints {
#ifndef VKFW_NO_STRUCT_CONSTRUCTORS
public:
VKFW_CONSTEXPR InitHints(
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(Platform)> platform_ = nullopt,
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(JoystickHatButtons)>
joystickHatButtons_ = nullopt,
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(AnglePlatformType)> anglePlatformType_ =
nullopt,
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(CocoaChdirResources)>
cocoaChdirResources_ = nullopt,
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(CocoaMenubar)> cocoaMenubar_ = nullopt,
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(WaylandLibDecor)> waylandLibDecor_ =
nullopt,
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(X11XCBVulkanSurface)>
x11XCBVulkanSurface_ = nullopt
) VKFW_NOEXCEPT : platform(platform_),
joystickHatButtons(joystickHatButtons_),
anglePlatformType(anglePlatformType_),
cocoaChdirResources(cocoaChdirResources_),
cocoaMenubar(cocoaMenubar_),
waylandLibDecor(waylandLibDecor_),
x11XCBVulkanSurface(x11XCBVulkanSurface_) {}
#endif
public:
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(Platform)> platform = nullopt;
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(JoystickHatButtons)> joystickHatButtons =
nullopt;
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(AnglePlatformType)> anglePlatformType =
nullopt;
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(CocoaChdirResources)> cocoaChdirResources =
nullopt;
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(CocoaMenubar)> cocoaMenubar = nullopt;
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(WaylandLibDecor)> waylandLibDecor =
nullopt;
OptionalInitializationHint<InitializationHint::VKFW_ENUMERATOR(X11XCBVulkanSurface)> x11XCBVulkanSurface =
nullopt;
};
template <InitializationHint hint>
VKFW_INLINE Result setInitHint(OptionalInitializationHint<hint> optional_hint) {
if (optional_hint.has_value())
return initHint<hint>(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 <WindowHint hint>
VKFW_INLINE Result windowHint(typename WindowHintTraits<hint>::type value) {
glfwWindowHint(static_cast<int>(hint), static_cast<int>(value));
return getError();
}
#ifndef VKFW_DISABLE_ENHANCED_MODE
template <WindowHint hint>
class OptionalWindowHint : public Optional<typename WindowHintTraits<hint>::type> {
public:
using Optional<typename WindowHintTraits<hint>::type>::Optional;
};
struct WindowHints {
#ifndef VKFW_NO_STRUCT_CONSTRUCTORS
public:
#if HAS_STRING_VIEW
VKFW_CONSTEXPR
#else
VKFW_INLINE
#endif
WindowHints(
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Resizable)> resizable_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Visible)> visible_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Decorated)> decorated_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Focused)> focused_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AutoIconify)> autoIconify_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Floating)> floating_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Maximized)> maximized_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CenterCursor)> centerCursor_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(TransparentFramebuffer)> transparentFramebuffer_ =
nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(FocusOnShow)> focusOnShow_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(MousePassthrough)> mousePassthrough_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(PositionX)> positionX_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(PositionY)> positionY_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ScaleToMonitor)> scaleToMonitor_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ScaleFramebuffer)> scaleFramebuffer_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(RedBits)> redBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(GreenBits)> greenBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(BlueBits)> blueBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AlphaBits)> alphaBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(DepthBits)> depthBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(StencilBits)> stencilBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationRedBits)> accumulationRedBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationGreenBits)> accumulationGreenBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationBlueBits)> accumulationBlueBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationAlphaBits)> accumulationAlphaBits_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AuxiliaryBuffers)> auxiliaryBuffers_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Samples)> samples_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(RefreshRate)> refreshRate_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(StereoscopicRendering)> stereo_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(SRGBCapable)> srgbCapable_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(DoubleBuffer)> doubleBuffer_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ClientAPI)> clientAPI_ = ClientAPI::VKFW_ENUMERATOR(None
),
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextCreationAPI)> contextCreationAPI_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Win32KeyboardMenu)> win32KeyboardMenu_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Win32ShowDefault)> win32ShowDefault_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextVersionMajor)> contextVersionMajor_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextVersionMinor)> contextVersionMinor_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextRobustness)> contextRobustness_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextReleaseBehavior)> contextReleaseBehavior_ =
nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextNoError)> contextNoError_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(OpenGLForwardCompatibility)>
openGLForwardCompatibility_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(OpenGLDebugContext)> openGLDebugContext_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(OpenGLProfile)> openGLProfile_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CocoaRetinaFramebuffer)> cocoaRetinaFramebuffer_ =
nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)> cocoaFrameName_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CocoaGraphicsSwitching)> cocoaGraphicsSwitching_ =
nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(X11ClassName)> x11ClassName_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(X11InstanceName)> x11InstanceName_ = nullopt,
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(WaylandAppID)> 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<WindowHint::VKFW_ENUMERATOR(Resizable)> resizable = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Visible)> visible = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Decorated)> decorated = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Focused)> focused = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AutoIconify)> autoIconify = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Floating)> floating = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Maximized)> maximized = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CenterCursor)> centerCursor = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(TransparentFramebuffer)> transparentFramebuffer = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(FocusOnShow)> focusOnShow = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(MousePassthrough)> mousePassthrough = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(PositionX)> positionX = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(PositionY)> positionY = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ScaleToMonitor)> scaleToMonitor = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ScaleFramebuffer)> scaleFramebuffer = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(RedBits)> redBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(GreenBits)> greenBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(BlueBits)> blueBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AlphaBits)> alphaBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(DepthBits)> depthBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(StencilBits)> stencilBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationRedBits)> accumulationRedBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationGreenBits)> accumulationGreenBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationBlueBits)> accumulationBlueBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AccumulationAlphaBits)> accumulationAlphaBits = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(AuxiliaryBuffers)> auxiliaryBuffers = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Samples)> samples = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(RefreshRate)> refreshRate = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(StereoscopicRendering)> stereo = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(SRGBCapable)> srgbCapable = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(DoubleBuffer)> doubleBuffer = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ClientAPI)> clientAPI = ClientAPI::VKFW_ENUMERATOR(None);
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextCreationAPI)> contextCreationAPI = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Win32KeyboardMenu)> win32KeyboardMenu = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(Win32ShowDefault)> win32ShowDefault = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextVersionMajor)> contextVersionMajor = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextVersionMinor)> contextVersionMinor = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextRobustness)> contextRobustness = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextReleaseBehavior)> contextReleaseBehavior = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(ContextNoError)> contextNoError = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(OpenGLForwardCompatibility)> openGLForwardCompatibility =
nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(OpenGLDebugContext)> openGLDebugContext = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(OpenGLProfile)> openGLProfile = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CocoaRetinaFramebuffer)> cocoaRetinaFramebuffer = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)> cocoaFrameName = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(CocoaGraphicsSwitching)> cocoaGraphicsSwitching = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(X11ClassName)> x11ClassName = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(X11InstanceName)> x11InstanceName = nullopt;
OptionalWindowHint<WindowHint::VKFW_ENUMERATOR(WaylandAppID)> waylandAppID = nullopt;
};
template <WindowHint hint>
Result setWindowHint(OptionalWindowHint<hint> optional_hint) {
if (optional_hint.has_value())
return windowHint<hint>(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 <InitializationHint hint>
VKFW_INLINE Result set(typename InitializationHintTraits<hint>::type value) {
return initHint<hint>(std::move(value));
}
template <WindowHint hint>
VKFW_INLINE Result set(typename WindowHintTraits<hint>::type value) {
return windowHint<hint>(std::move(value));
}
#ifdef VKFW_DISABLE_ENHANCED_MODE
VKFW_NODISCARD Result init();
VKFW_NODISCARD Result terminate();
#else
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type init(InitHints hints = {});
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type terminate();
#ifndef VKFW_NO_SMART_HANDLE
using UniqueInstance = UniqueHandle<Instance>;
VKFW_NODISCARD typename ResultValueType<UniqueInstance>::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<size_t>(major), static_cast<size_t>(minor), static_cast<size_t>(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<GLFWmonitor*> getMonitors();
#else
VKFW_NODISCARD GLFWmonitor** getMonitors(size_t* count);
#endif
#else
VKFW_NODISCARD typename ResultValueType<Monitor>::type getPrimaryMonitor();
VKFW_NODISCARD typename ResultValueType<std::vector<Monitor>>::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<GLFWvidmode const> 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<Window>::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<Window>;
VKFW_NODISCARD typename ResultValueType<UniqueWindow>::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<vkfw::Image> images);
#endif
void setWindowIcon(GLFWwindow* window, std::vector<vkfw::Image> images);
void setWindowIcon(GLFWwindow* window, int count, vkfw::Image const* images);
template <Attribute attribute>
VKFW_NODISCARD typename ResultValueType<typename AttributeTraits<attribute>::type>::type getWindowAttribute(
GLFWwindow* window
);
template <Attribute attribute, typename = typename std::enable_if<AttributeTraits<attribute>::value>::type>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setWindowAttribute(GLFWwindow* window, typename AttributeTraits<attribute>::type const& new_value);
template <Attribute attribute>
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<typename AttributeTraits<attribute>::type>::type get(
GLFWwindow* window
) {
return getWindowAttribute<attribute>(window);
}
template <Attribute attribute, typename = typename std::enable_if<AttributeTraits<attribute>::value>::type>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type
set(GLFWwindow* window, typename AttributeTraits<attribute>::type const& new_value) {
return setWindowAttribute<attribute>(window, new_value);
}
template <InputMode mode>
VKFW_NODISCARD typename ResultValueType<typename InputModeTraits<mode>::type>::type getInputMode(
GLFWwindow* window
);
template <InputMode mode>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type
setInputMode(GLFWwindow* window, typename InputModeTraits<mode>::type const& new_value);
template <InputMode mode>
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<typename InputModeTraits<mode>::type>::type get(
GLFWwindow* window
) {
return getInputMode<mode>(window);
}
template <InputMode mode>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type
set(GLFWwindow* window, typename InputModeTraits<mode>::type const& new_value) {
return setInputMode<mode>(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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
}
#endif
VKFW_NODISCARD typename ResultValueType<void*>::type getWindowUserPointer(GLFWwindow* window);
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::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<void>::type pollEvents();
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitEvents();
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitEventsTimeout(double timeout);
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type waitEventsTimeout(
std::chrono::duration<double> timeout
);
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type postEmptyEvent();
VKFW_NODISCARD typename ResultValueType<Window>::type getCurrentContext();
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type swapInterval(int interval);
VKFW_NODISCARD typename ResultValueType<bool>::type rawMouseMotionSupported();
#ifdef VKFW_HAS_STRING_VIEW
VKFW_NODISCARD typename ResultValueType<std::string_view>::type getKeyName(Key key, int32_t scancode = 0);
#else
VKFW_NODISCARD typename ResultValueType<char const*>::type getKeyName(Key key, int32_t scancode = 0);
#endif
VKFW_NODISCARD typename ResultValueType<int>::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<Cursor>::type
createCursor(vkfw::Image const& image, int xhot, int yhot);
VKFW_NODISCARD typename ResultValueType<Cursor>::type createStandardCursor(CursorShape shape);
#ifndef VKFW_NO_SMART_HANDLE
using UniqueCursor = UniqueHandle<Cursor>;
VKFW_NODISCARD typename ResultValueType<UniqueCursor>::type
createCursorUnique(vkfw::Image const& image, int xhot, int yhot);
VKFW_NODISCARD typename ResultValueType<UniqueCursor>::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<void>::type setClipboardString(
std::string_view string
);
VKFW_NODISCARD typename ResultValueType<std::string_view>::type getClipboardString();
#else
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setClipboardString(char const* string
);
VKFW_NODISCARD typename ResultValueType<char const*>::type getClipboardString();
#endif
VKFW_NODISCARD typename ResultValueType<double>::type getTime();
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS typename ResultValueType<void>::type setTime(double time);
VKFW_NODISCARD typename ResultValueType<uint64_t>::type getTimerValue();
VKFW_NODISCARD typename ResultValueType<uint64_t>::type getTimerFrequency();
#endif
VKFW_NODISCARD VKFW_INLINE bool joystickPresent(Joystick jid) {
return static_cast<bool>(glfwJoystickPresent(static_cast<int>(jid)));
}
VKFW_NODISCARD VKFW_INLINE float const* getJoystickAxes(Joystick jid, int* count) {
return glfwGetJoystickAxes(static_cast<int>(jid), count);
}
VKFW_NODISCARD VKFW_INLINE const unsigned char* getJoystickButtons(Joystick jid, int* count) {
return glfwGetJoystickButtons(static_cast<int>(jid), count);
}
VKFW_NODISCARD VKFW_INLINE const unsigned char* getJoystickHats(Joystick jid, int* count) {
return glfwGetJoystickHats(static_cast<int>(jid), count);
}
#ifdef VKFW_HAS_STRING_VIEW
VKFW_NODISCARD VKFW_INLINE std::string_view getJoystickName(Joystick jid) {
return glfwGetJoystickName(static_cast<int>(jid));
}
VKFW_NODISCARD VKFW_INLINE std::string_view getJoystickGUID(Joystick jid) {
return glfwGetJoystickGUID(static_cast<int>(jid));
}
#else
VKFW_NODISCARD VKFW_INLINE char const* getJoystickName(Joystick jid) {
return glfwGetJoystickName(static_cast<int>(jid));
}
VKFW_NODISCARD VKFW_INLINE char const* getJoystickGUID(Joystick jid) {
return glfwGetJoystickGUID(static_cast<int>(jid));
}
#endif
VKFW_INLINE void getJoystickUserPointer(Joystick jid, void* pointer) {
glfwSetJoystickUserPointer(static_cast<int>(jid), pointer);
}
VKFW_NODISCARD VKFW_INLINE void* getJoystickUserPointer(Joystick jid) {
return glfwGetJoystickUserPointer(static_cast<int>(jid));
}
VKFW_NODISCARD VKFW_INLINE bool joystickIsGamepad(Joystick jid) {
return static_cast<bool>(glfwJoystickIsGamepad(static_cast<int>(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<bool>(glfwUpdateGamepadMappings(string.data()));
}
#endif
VKFW_NODISCARD VKFW_INLINE bool updateGamepadMappings(char const* string) {
return static_cast<bool>(glfwUpdateGamepadMappings(string));
}
#ifdef VKFW_HAS_STRING_VIEW
VKFW_NODISCARD VKFW_INLINE char const* getGamepadName(Joystick jid) {
return glfwGetGamepadName(static_cast<int>(jid));
}
#else
VKFW_NODISCARD VKFW_INLINE char const* getGamepadName(Joystick jid) {
return glfwGetGamepadName(static_cast<int>(jid));
}
#endif
VKFW_NODISCARD VKFW_INLINE bool getGamepadState(Joystick jid, GLFWgamepadstate* state) {
return static_cast<bool>(glfwGetGamepadState(static_cast<int>(jid), state));
}
VKFW_NODISCARD VKFW_INLINE bool extensionSupported(char const* extension) {
return static_cast<bool>(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<char const*> getRequiredInstanceExtensions() {
uint32_t count;
auto pointer = glfwGetRequiredInstanceExtensions(&count);
return std::span<char const*>(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<bool>(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<vk::Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> 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<void(window_type, int, int)> on_window_move;
std::function<void(window_type, size_t, size_t)> on_window_resize;
std::function<void(window_type)> on_window_close;
std::function<void(window_type)> on_window_refresh;
std::function<void(window_type, bool)> on_window_focus;
std::function<void(window_type, bool)> on_window_iconify;
std::function<void(window_type, bool)> on_window_maximize;
std::function<void(window_type, size_t, size_t)> on_framebuffer_resize;
std::function<void(window_type, float, float)> on_window_content_scale_change;
std::function<void(window_type, MouseButton, MouseButtonAction, ModifierKeyFlags)> on_mouse_button;
std::function<void(window_type, double, double)> on_cursor_move;
std::function<void(window_type, bool)> on_cursor_enter;
std::function<void(window_type, double, double)> on_scroll;
std::function<void(window_type, Key, int32_t, KeyAction, ModifierKeyFlags)> on_key;
std::function<void(window_type, uint32_t)> on_character;
#ifdef VKFW_HAS_STRING_VIEW
std::function<void(window_type, std::vector<std::string_view>)> on_drop;
#else
std::function<void(window_type, std::vector<char const*>)> on_drop;
#endif
};
} // namespace VKFW_NAMESPACE
#endif
#ifndef VKFW_NO_SMART_HANDLE
template <>
struct VKFW_NAMESPACE::CustomDestroy<VKFW_NAMESPACE::Instance> {
VKFW_INLINE void destroy(Instance& instance) { static_cast<void>(instance.destroy()); }
};
#ifndef VKFW_NO_INCLUDE_VULKAN_HPP
template <>
class VULKAN_HPP_NAMESPACE::UniqueHandleTraits<VKFW_NAMESPACE::Instance, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> {
#else
template <>
class VKFW_NAMESPACE::UniqueHandleTraits<VKFW_NAMESPACE::Instance> {
#endif
public:
using deleter = VKFW_NAMESPACE::CustomDestroy<VKFW_NAMESPACE::Instance>;
};
template <>
struct VKFW_NAMESPACE::CustomDestroy<VKFW_NAMESPACE::Window> {
VKFW_INLINE void destroy(Window& window) { static_cast<void>(window.destroy()); }
};
#ifndef VKFW_NO_INCLUDE_VULKAN_HPP
template <>
class VULKAN_HPP_NAMESPACE::UniqueHandleTraits<VKFW_NAMESPACE::Window, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> {
#else
template <>
class VKFW_NAMESPACE::UniqueHandleTraits<VKFW_NAMESPACE::Window> {
#endif
public:
using deleter = VKFW_NAMESPACE::CustomDestroy<VKFW_NAMESPACE::Window>;
};
template <>
struct VKFW_NAMESPACE::CustomDestroy<VKFW_NAMESPACE::Cursor> {
VKFW_INLINE void destroy(Cursor& cursor) { static_cast<void>(cursor.destroy()); }
};
#ifndef VKFW_NO_INCLUDE_VULKAN_HPP
template <>
class VULKAN_HPP_NAMESPACE::UniqueHandleTraits<VKFW_NAMESPACE::Cursor, VULKAN_HPP_DEFAULT_DISPATCHER_TYPE> {
#else
template <>
class VKFW_NAMESPACE::UniqueHandleTraits<VKFW_NAMESPACE::Cursor> {
#endif
public:
using deleter = VKFW_NAMESPACE::CustomDestroy<VKFW_NAMESPACE::Cursor>;
};
#endif
namespace VKFW_NAMESPACE {
#ifndef VKFW_DISABLE_ENHANCED_MODE
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<void>::type Window::destroy() {
if (m_window) {
#ifndef VKFW_NO_STD_FUNCTION_CALLBACKS
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(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<void>::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<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(CocoaFrameName)), value.data());
return getError();
}
#else
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(CocoaFrameName)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(CocoaFrameName)), value);
return getError();
}
#endif
#ifdef VKFW_HAS_STRING_VIEW
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(X11ClassName)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(X11ClassName)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(X11ClassName)), value.data());
return getError();
}
#else
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(X11ClassName)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(X11ClassName)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(X11ClassName)), value);
return getError();
}
#endif
#ifdef VKFW_HAS_STRING_VIEW
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(X11InstanceName)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(X11InstanceName)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(X11InstanceName)), value.data());
return getError();
}
#else
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(X11InstanceName)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(X11InstanceName)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(X11InstanceName)), value);
return getError();
}
#endif
#ifdef VKFW_HAS_STRING_VIEW
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(WaylandAppID)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(WaylandAppID)>::type value
) {
glfwWindowHintString(static_cast<int>(WindowHint::VKFW_ENUMERATOR(WaylandAppID)), value.data());
return getError();
}
#else
template <>
VKFW_INLINE Result windowHint<WindowHint::VKFW_ENUMERATOR(WaylandAppID)>(
typename WindowHintTraits<WindowHint::VKFW_ENUMERATOR(WaylandAppID)>::type value
) {
glfwWindowHintString(static_cast<int>(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<void>::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<void>::type terminate() {
glfwTerminate();
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::terminate");
}
#ifndef VKFW_NO_SMART_HANDLE
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<VKFW_NAMESPACE::UniqueInstance>::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<GLFWmonitor*> getMonitors() {
int tmp_count;
auto** output = glfwGetMonitors(&tmp_count);
return std::span<GLFWmonitor*>(output, static_cast<size_t>(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<size_t>(tmp_count > 0 ? tmp_count : 0);
return output;
}
#endif
#else
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<Monitor>::type getPrimaryMonitor() {
Monitor monitor = glfwGetPrimaryMonitor();
return createResultValue(getError(), monitor, VKFW_NAMESPACE_STRING "::getPrimaryMonitor");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<std::vector<Monitor>>::type getMonitors() {
std::vector<Monitor> output;
int count;
auto ptr = glfwGetMonitors(&count);
Result result = getError();
if (check(result)) {
output.reserve(static_cast<size_t>(count));
std::transform(ptr, ptr + count, std::back_inserter(output), [](GLFWmonitor* monitor) {
return Monitor(monitor);
});
VKFW_ASSERT(output.size() == static_cast<size_t>(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<GLFWvidmode const> getVideoModes(GLFWmonitor* monitor) {
int count;
GLFWvidmode const* pointer = glfwGetVideoModes(monitor, &count);
return std::span<GLFWvidmode const>(pointer, static_cast<size_t>(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<void>::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<std::tuple<int, int>>::type Monitor::getPos() const {
std::tuple<int, int> 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<int>::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<int>::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<void>::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<std::tuple<int, int, size_t, size_t>>::type
Monitor::getWorkarea() const {
std::tuple<int, int, size_t, size_t> 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<std::tuple<int, int>>::type Monitor::getWorkareaPos(
) const {
std::tuple<int, int> 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<int>::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<int>::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<std::tuple<size_t, size_t>>::type
Monitor::getWorkareaSize() const {
std::tuple<size_t, size_t> 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<size_t>::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<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaWidth");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<size_t>::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<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getWorkareaHeight");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<std::tuple<size_t, size_t>>::type
Monitor::getPhysicalSize() const {
std::tuple<size_t, size_t> 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<size_t>::type Monitor::getPhysicalWidth() const {
size_t output;
int temp;
glfwGetMonitorPhysicalSize(m_monitor, &temp, nullptr);
Result result = getError();
if (check(result))
output = static_cast<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getPhysicalWidth");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<size_t>::type Monitor::getPhysicalHeight() const {
size_t output;
int temp;
glfwGetMonitorPhysicalSize(m_monitor, nullptr, &temp);
Result result = getError();
if (check(result))
output = static_cast<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Monitor::getPhysicalHeight");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<std::tuple<float, float>>::type
Monitor::getContentScale() const {
std::tuple<float, float> 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<float>::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<float>::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<std::string_view>::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<char const*>::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<void>::type Monitor::setUserPointer(
void* pointer
) const {
glfwSetMonitorUserPointer(m_monitor, pointer);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::setUserPointer");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<void*>::type Monitor::getUserPointer() const {
void* output = glfwGetMonitorUserPointer(m_monitor);
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getUserPointer");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<GLFWvidmode const*>::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<std::span<GLFWvidmode const>>::type
Monitor::getVideoModes() const {
int count;
GLFWvidmode const* pointer = glfwGetVideoModes(m_monitor, &count);
std::span<GLFWvidmode const> output(pointer, static_cast<size_t>(count));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getVideoModes");
}
#else
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<std::vector<GLFWvidmode>>::type Monitor::getVideoModes(
) const {
int count;
GLFWvidmode const* pointer = glfwGetVideoModes(m_monitor, &count);
std::vector<GLFWvidmode> output(pointer, pointer + static_cast<size_t>(count));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Monitor::getVideoModes");
}
#endif
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Monitor::setGamma(
float gamma
) const {
glfwSetGamma(m_monitor, gamma);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Monitor::setGamma");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<GLFWgammaramp const*>::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<void>::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<int>(width), static_cast<int>(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<DynamicCallbackStorage*>(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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_window_resize)
ptr->on_window_resize(window, static_cast<size_t>(width), static_cast<size_t>(height));
});
glfwSetWindowCloseCallback(window_ptr, [](GLFWwindow* window) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_window_close)
ptr->on_window_close(window);
});
glfwSetWindowRefreshCallback(window_ptr, [](GLFWwindow* window) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_window_refresh)
ptr->on_window_refresh(window);
});
glfwSetWindowFocusCallback(window_ptr, [](GLFWwindow* window, int focused) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_window_focus)
ptr->on_window_focus(window, static_cast<bool>(focused));
});
glfwSetWindowIconifyCallback(window_ptr, [](GLFWwindow* window, int iconified) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_window_iconify)
ptr->on_window_iconify(window, static_cast<bool>(iconified));
});
glfwSetWindowMaximizeCallback(window_ptr, [](GLFWwindow* window, int maximized) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_window_maximize)
ptr->on_window_maximize(window, static_cast<bool>(maximized));
});
glfwSetFramebufferSizeCallback(window_ptr, [](GLFWwindow* window, int width, int height) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_framebuffer_resize)
ptr->on_framebuffer_resize(window, static_cast<size_t>(width), static_cast<size_t>(height));
});
glfwSetWindowContentScaleCallback(window_ptr, [](GLFWwindow* window, float xscale, float yscale) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_mouse_button)
ptr->on_mouse_button(
window,
static_cast<MouseButton>(button),
static_cast<MouseButtonAction>(action),
static_cast<ModifierKeyFlags>(mods)
);
});
glfwSetCursorPosCallback(window_ptr, [](GLFWwindow* window, double xpos, double ypos) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_cursor_enter)
ptr->on_cursor_enter(window, static_cast<bool>(entered));
});
glfwSetScrollCallback(window_ptr, [](GLFWwindow* window, double xoffset, double yoffset) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_key)
ptr->on_key(
window,
static_cast<Key>(key),
scancode,
static_cast<KeyAction>(action),
static_cast<ModifierKeyFlags>(mods)
);
});
glfwSetCharCallback(window_ptr, [](GLFWwindow* window, unsigned int codepoint) {
auto* ptr = reinterpret_cast<DynamicCallbackStorage*>(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<DynamicCallbackStorage*>(glfwGetWindowUserPointer(window));
if (ptr && ptr->on_drop) {
#ifdef VKFW_HAS_STRING_VIEW
std::vector<std::string_view> 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<char const *>(paths, paths + path_count));
#endif
}
});
}
}
#endif
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<Window>::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<int>(width), static_cast<int>(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<UniqueWindow>::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<int>(width), static_cast<int>(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<bool>(glfwWindowShouldClose(window));
}
VKFW_INLINE void setWindowShouldClose(GLFWwindow* window, bool value) {
glfwSetWindowShouldClose(window, static_cast<int>(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<int>(minimum_width),
static_cast<int>(minimum_height),
static_cast<int>(maximum_width),
static_cast<int>(maximum_height)
);
}
VKFW_INLINE void setWindowAspectRatio(GLFWwindow* window, size_t numerator, size_t denominator) {
glfwSetWindowAspectRatio(window, static_cast<int>(numerator), static_cast<int>(denominator));
}
VKFW_INLINE void setWindowSize(GLFWwindow* window, size_t width, size_t height) {
glfwSetWindowSize(window, static_cast<int>(width), static_cast<int>(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<int>(width),
static_cast<int>(height),
static_cast<int>(refreshRate)
);
}
#ifdef VKFW_HAS_SPAN
VKFW_INLINE void setWindowIcon(GLFWwindow* window, std::span<vkfw::Image> images) {
glfwSetWindowIcon(window, static_cast<int>(images.size()), images.data());
}
#endif
VKFW_INLINE void setWindowIcon(GLFWwindow* window, std::vector<vkfw::Image> images) {
glfwSetWindowIcon(window, static_cast<int>(images.size()), images.data());
}
VKFW_INLINE void setWindowIcon(GLFWwindow* window, int image_count, vkfw::Image const* images) {
glfwSetWindowIcon(window, static_cast<int>(image_count), images);
}
template <Attribute attribute>
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<typename AttributeTraits<attribute>::type>::type
getWindowAttribute(GLFWwindow* window) {
auto output = static_cast<typename AttributeTraits<attribute>::type>(
glfwGetWindowAttrib(window, static_cast<int>(attribute))
);
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getWindowAttribute");
}
template <Attribute attribute, typename>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type
setWindowAttribute(GLFWwindow* window, typename AttributeTraits<attribute>::type const& new_value) {
glfwSetWindowAttrib(window, static_cast<int>(attribute), static_cast<int>(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<void>::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<int>(key)) == static_cast<int>(KeyAction::VKFW_ENUMERATOR(Press));
}
VKFW_NODISCARD VKFW_INLINE bool getMouseButton(GLFWwindow* window, MouseButton button) {
return glfwGetKey(window, static_cast<int>(button)) ==
static_cast<int>(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<bool>::type Window::shouldClose() const {
auto output = static_cast<bool>(glfwWindowShouldClose(m_window));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::shouldClose");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<void>::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<void>::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<void>::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<std::tuple<int, int>>::type Window::getPos() const {
std::tuple<int, int> 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<int>::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<int>::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<void>::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<void>::type Window::setPos(
std::tuple<int, int> 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<void>::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<std::tuple<size_t, size_t>>::type Window::getSize(
) const {
std::tuple<size_t, size_t> 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<size_t>::type Window::getWidth() const {
size_t output;
int temp;
glfwGetWindowSize(m_window, &temp, nullptr);
Result result = getError();
if (check(result))
output = static_cast<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getWidth");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<size_t>::type Window::getHeight() const {
size_t output;
int temp;
glfwGetWindowSize(m_window, nullptr, &temp);
Result result = getError();
if (check(result))
output = static_cast<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getHeight");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type
Window::setSize(size_t width, size_t height) const {
glfwSetWindowSize(m_window, static_cast<int>(width), static_cast<int>(height));
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSize");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::setSize(
std::tuple<size_t, size_t> size
) const {
glfwSetWindowSize(m_window, static_cast<int>(std::get<0>(size)), static_cast<int>(std::get<1>(size)));
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSize");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<int>(minimum_width),
static_cast<int>(minimum_height),
static_cast<int>(maximum_width),
static_cast<int>(maximum_height)
);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSizeLimits");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::setSizeLimits(
std::tuple<size_t, size_t> minimum_size,
std::tuple<size_t, size_t> maximum_size
) const {
glfwSetWindowSizeLimits(
m_window,
static_cast<int>(std::get<0>(minimum_size)),
static_cast<int>(std::get<1>(minimum_size)),
static_cast<int>(std::get<0>(maximum_size)),
static_cast<int>(std::get<1>(maximum_size))
);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSizeLimits");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::setSizeLimits(
std::tuple<size_t, size_t, size_t, size_t> limits
) const {
glfwSetWindowSizeLimits(
m_window,
static_cast<int>(std::get<0>(limits)),
static_cast<int>(std::get<1>(limits)),
static_cast<int>(std::get<2>(limits)),
static_cast<int>(std::get<3>(limits))
);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setSizeLimits");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type
Window::setAspectRatio(size_t numerator, size_t denominator) const {
glfwSetWindowAspectRatio(m_window, static_cast<int>(numerator), static_cast<int>(denominator));
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setAspectRatio");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<std::tuple<size_t, size_t>>::type
Window::getFramebufferSize() const {
std::tuple<size_t, size_t> 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<size_t>::type Window::getFramebufferWidth() const {
size_t output;
int temp;
glfwGetFramebufferSize(m_window, &temp, nullptr);
Result result = getError();
if (check(result))
output = static_cast<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getFramebufferWidth");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<size_t>::type Window::getFramebufferHeight() const {
size_t output;
int temp;
glfwGetFramebufferSize(m_window, nullptr, &temp);
Result result = getError();
if (check(result))
output = static_cast<size_t>(temp);
else
output = 0u;
return createResultValue(result, output, VKFW_NAMESPACE_STRING "::Window::getFramebufferHeight");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<std::tuple<size_t, size_t, size_t, size_t>>::type
Window::getFrameSize() const {
std::tuple<size_t, size_t, size_t, size_t> 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<size_t>::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<size_t>::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<size_t>::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<size_t>::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<void>::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<std::tuple<float, float>>::type Window::getContentScale(
) const {
std::tuple<float, float> 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<float>::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<float>::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<float>::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<void>::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<void>::type Window::iconify() const {
glfwIconifyWindow(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::iconify");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::restore() const {
glfwRestoreWindow(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::restore");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::maximize(
) const {
glfwMaximizeWindow(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::maximize");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::show() const {
glfwShowWindow(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::show");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::hide() const {
glfwHideWindow(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::hide");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::focus() const {
glfwFocusWindow(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::focus");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::requestAttention(
) const {
glfwRequestWindowAttention(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::requestAttention");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<Monitor>::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<void>::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<int>(width),
static_cast<int>(height),
static_cast<int>(refreshRate)
);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setMonitor");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::setMonitor(
Monitor const& monitor,
std::tuple<int, int> pos,
std::tuple<size_t, size_t> size,
size_t refreshRate
) const {
glfwSetWindowMonitor(
m_window,
monitor,
std::get<0>(pos),
std::get<1>(pos),
static_cast<int>(std::get<0>(size)),
static_cast<int>(std::get<1>(size)),
static_cast<int>(refreshRate)
);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setMonitor");
}
template <Attribute attribute>
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<typename AttributeTraits<attribute>::type>::type
Window::get() const {
auto output = static_cast<typename AttributeTraits<attribute>::type>(
glfwGetWindowAttrib(m_window, static_cast<int>(attribute))
);
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::get");
}
template <Attribute attribute, typename>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::set(
typename AttributeTraits<attribute>::type const& new_value
) const {
glfwSetWindowAttrib(m_window, static_cast<int>(attribute), static_cast<int>(new_value));
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::set");
}
template <InputMode mode>
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<typename InputModeTraits<mode>::type>::type Window::get(
) const {
auto output =
static_cast<typename InputModeTraits<mode>::type>(glfwGetInputMode(m_window, static_cast<int>(mode)));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::get");
}
template <InputMode mode>
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::set(
typename InputModeTraits<mode>::type const& new_value
) const {
glfwSetInputMode(m_window, static_cast<int>(mode), static_cast<int>(new_value));
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::set");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<void*>::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<void>::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<void>::type Window::setIcon(
std::span<vkfw::Image> images
) const {
glfwSetWindowIcon(m_window, static_cast<int>(images.size()), images.data());
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setIcon");
}
#endif
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type Window::setIcon(
std::vector<vkfw::Image> images
) const {
glfwSetWindowIcon(m_window, static_cast<int>(images.size()), images.data());
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setIcon");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type
Window::setIcon(size_t image_count, vkfw::Image* images) const {
glfwSetWindowIcon(m_window, static_cast<int>(image_count), images);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::setIcon");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<bool>::type Window::getKey(Key key) const {
bool output =
glfwGetKey(m_window, static_cast<int>(key)) == static_cast<int>(KeyAction::VKFW_ENUMERATOR(Press));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getKey");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<bool>::type Window::getMouseButton(MouseButton button
) const {
bool output = glfwGetMouseButton(m_window, static_cast<int>(button)) ==
static_cast<int>(MouseButtonAction::VKFW_ENUMERATOR(Press));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::Window::getMouseButton");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<std::tuple<double, double>>::type Window::getCursorPos(
) const {
std::tuple<double, double> 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<double>::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<double>::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<void>::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<void>::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<void>::type
Window::makeContextCurrent() const {
glfwMakeContextCurrent(m_window);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::Window::makeContextCurrent");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::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<bool>(glfwRawMouseMotionSupported());
}
#ifdef VKFW_HAS_STRING_VIEW
VKFW_NODISCARD VKFW_INLINE std::string_view getKeyName(Key key, int scancode) {
char const* tmp = glfwGetKeyName(static_cast<int>(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<int>(key), scancode);
}
#endif
VKFW_NODISCARD VKFW_INLINE int getKeyScancode(Key key) { return glfwGetKeyScancode(static_cast<int>(key)); }
#else
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type pollEvents() {
glfwPollEvents();
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::pollEvents");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type waitEvents() {
glfwWaitEvents();
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::waitEvents");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type waitEventsTimeout(
double timeout
) {
glfwWaitEventsTimeout(timeout);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::waitEventsTimeout");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type waitEventsTimeout(
std::chrono::duration<double> timeout
) {
glfwWaitEventsTimeout(timeout.count());
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::waitEventsTimeout");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type postEmptyEvent() {
glfwPostEmptyEvent();
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::postEmptyEvent");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<Window>::type getCurrentContext() {
Window output = glfwGetCurrentContext();
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getCurrentContext");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type swapInterval(int interval
) {
glfwSwapInterval(interval);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::swapInterval");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<bool>::type rawMouseMotionSupported() {
bool output = static_cast<bool>(glfwRawMouseMotionSupported());
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::rawMouseMotionSupported");
}
#ifdef VKFW_HAS_STRING_VIEW
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<std::string_view>::type
getKeyName(Key key, int32_t scancode) {
char const* tmp = glfwGetKeyName(static_cast<int>(key), static_cast<int>(scancode));
std::string_view output;
if (tmp)
output = tmp;
#else
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<char const*>::type
getKeyName(Key key, int32_t scancode) {
char const* output = glfwGetKeyName(static_cast<int>(key), static_cast<int>(scancode));
#endif
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::rawMouseMotionSupported");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<int>::type getKeyScancode(Key key) {
int32_t output = static_cast<int32_t>(glfwGetKeyScancode(static_cast<int>(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<int>(shape));
}
VKFW_NODISCARD VKFW_INLINE Result destroyCursor(GLFWcursor* cursor) {
glfwDestroyCursor(cursor);
return getError();
}
#else
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<Cursor>::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<Cursor>::type createStandardCursor(CursorShape shape) {
Cursor output = glfwCreateStandardCursor(static_cast<int>(shape));
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::createStandardCursor");
}
#ifndef VKFW_NO_SMART_HANDLE
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<UniqueCursor>::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<UniqueCursor>::type createStandardCursorUnique(
CursorShape shape
) {
Cursor output = glfwCreateStandardCursor(static_cast<int>(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<void>::type setClipboardString(
std::string_view string
) {
glfwSetClipboardString(nullptr, string.data());
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setClipboardString");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<std::string_view>::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<void>::type setClipboardString(
char const* string
) {
glfwSetClipboardString(nullptr, string);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setClipboardString");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<char const*>::type getClipboardString() {
char const* output = glfwGetClipboardString(nullptr);
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getClipboardString");
}
#endif
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<double>::type getTime() {
double output = glfwGetTime();
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getTime");
}
VKFW_NODISCARD_WHEN_NO_EXCEPTIONS VKFW_INLINE typename ResultValueType<void>::type setTime(double time) {
glfwSetTime(time);
return createResultValue(getError(), VKFW_NAMESPACE_STRING "::setTime");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<uint64_t>::type getTimerValue() {
uint64_t output = glfwGetTimerValue();
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getTimerValue");
}
VKFW_NODISCARD VKFW_INLINE typename ResultValueType<uint64_t>::type getTimerFrequency() {
uint64_t output = glfwGetTimerFrequency();
return createResultValue(getError(), output, VKFW_NAMESPACE_STRING "::getTimerFrequency");
}
#endif
} // namespace VKFW_NAMESPACE
View git blame Copy permalink