2526 lines
106 KiB
C
2526 lines
106 KiB
C
/**********************************************************************************************
|
|
*
|
|
* rcore_desktop - Functions to manage window, graphics device and inputs
|
|
*
|
|
* PLATFORM: DESKTOP: GLFW
|
|
* - Windows (Win32, Win64)
|
|
* - Linux (X11/Wayland desktop mode)
|
|
* - FreeBSD, OpenBSD, NetBSD, DragonFly (X11 desktop)
|
|
* - OSX/macOS (x64, arm64)
|
|
*
|
|
* LIMITATIONS:
|
|
* - Limitation 01
|
|
* - Limitation 02
|
|
*
|
|
* POSSIBLE IMPROVEMENTS:
|
|
* - Improvement 01
|
|
* - Improvement 02
|
|
*
|
|
* ADDITIONAL NOTES:
|
|
* - TRACELOG() function is located in raylib [utils] module
|
|
*
|
|
* CONFIGURATION:
|
|
* #define RCORE_PLATFORM_CUSTOM_FLAG
|
|
* Custom flag for rcore on target platform -not used-
|
|
*
|
|
* DEPENDENCIES:
|
|
* - rglfw: Manage graphic device, OpenGL context and inputs (Windows, Linux, OSX, FreeBSD...)
|
|
* - gestures: Gestures system for touch-ready devices (or simulated from mouse inputs)
|
|
*
|
|
*
|
|
* LICENSE: zlib/libpng
|
|
*
|
|
* Copyright (c) 2013-2024 Ramon Santamaria (@raysan5) and contributors
|
|
*
|
|
* This software is provided "as-is", without any express or implied warranty. In no event
|
|
* will the authors be held liable for any damages arising from the use of this software.
|
|
*
|
|
* Permission is granted to anyone to use this software for any purpose, including commercial
|
|
* applications, and to alter it and redistribute it freely, subject to the following restrictions:
|
|
*
|
|
* 1. The origin of this software must not be misrepresented; you must not claim that you
|
|
* wrote the original software. If you use this software in a product, an acknowledgment
|
|
* in the product documentation would be appreciated but is not required.
|
|
*
|
|
* 2. Altered source versions must be plainly marked as such, and must not be misrepresented
|
|
* as being the original software.
|
|
*
|
|
* 3. This notice may not be removed or altered from any source distribution.
|
|
*
|
|
**********************************************************************************************/
|
|
|
|
#define GLFW_INCLUDE_NONE // Disable the standard OpenGL header inclusion on GLFW3
|
|
// NOTE: Already provided by rlgl implementation (on glad.h)
|
|
#include "GLFW/glfw3.h" // GLFW3 library: Windows, OpenGL context and Input management
|
|
// NOTE: GLFW3 already includes gl.h (OpenGL) headers
|
|
|
|
// Support retrieving native window handlers
|
|
#if defined(_WIN32)
|
|
typedef void *PVOID;
|
|
typedef PVOID HANDLE;
|
|
typedef HANDLE HWND;
|
|
#define GLFW_EXPOSE_NATIVE_WIN32
|
|
#define GLFW_NATIVE_INCLUDE_NONE // To avoid some symbols re-definition in windows.h
|
|
#include "GLFW/glfw3native.h"
|
|
|
|
#if defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP)
|
|
// NOTE: Those functions require linking with winmm library
|
|
unsigned int __stdcall timeBeginPeriod(unsigned int uPeriod);
|
|
unsigned int __stdcall timeEndPeriod(unsigned int uPeriod);
|
|
#endif
|
|
#endif
|
|
#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
#include <sys/time.h> // Required for: timespec, nanosleep(), select() - POSIX
|
|
|
|
//#define GLFW_EXPOSE_NATIVE_X11 // WARNING: Exposing Xlib.h > X.h results in dup symbols for Font type
|
|
//#define GLFW_EXPOSE_NATIVE_WAYLAND
|
|
#include "GLFW/glfw3native.h" // Required for: glfwGetX11Window()
|
|
#endif
|
|
#if defined(__APPLE__)
|
|
#include <unistd.h> // Required for: usleep()
|
|
|
|
//#define GLFW_EXPOSE_NATIVE_COCOA // WARNING: Fails due to type redefinition
|
|
void *glfwGetCocoaWindow(GLFWwindow* handle);
|
|
#include "GLFW/glfw3native.h" // Required for: glfwGetCocoaWindow()
|
|
#endif
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Types and Structures Definition
|
|
//----------------------------------------------------------------------------------
|
|
typedef struct {
|
|
GLFWwindow *handle; // GLFW window handle (graphic device)
|
|
} PlatformData;
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Global Variables Definition
|
|
//----------------------------------------------------------------------------------
|
|
extern CoreData CORE; // Global CORE state context
|
|
|
|
static PlatformData platform = { 0 }; // Platform specific data
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Internal Functions Declaration
|
|
//----------------------------------------------------------------------------------
|
|
int InitPlatform(void); // Initialize platform (graphics, inputs and more)
|
|
void ClosePlatform(void); // Close platform
|
|
|
|
// Error callback event
|
|
static void ErrorCallback(int error, const char *description); // GLFW3 Error Callback, runs on GLFW3 error
|
|
|
|
// Window callbacks events
|
|
static void WindowSizeCallback(GLFWwindow *window, int width, int height); // GLFW3 WindowSize Callback, runs when window is resized
|
|
static void WindowIconifyCallback(GLFWwindow *window, int iconified); // GLFW3 WindowIconify Callback, runs when window is minimized/restored
|
|
static void WindowMaximizeCallback(GLFWwindow* window, int maximized); // GLFW3 Window Maximize Callback, runs when window is maximized
|
|
static void WindowFocusCallback(GLFWwindow *window, int focused); // GLFW3 WindowFocus Callback, runs when window get/lose focus
|
|
static void WindowDropCallback(GLFWwindow *window, int count, const char **paths); // GLFW3 Window Drop Callback, runs when drop files into window
|
|
static void WindowContentScaleCallback(GLFWwindow *window, float scalex, float scaley); // GLFW3 Window Content Scale Callback, runs when window changes scale
|
|
|
|
// Input callbacks events
|
|
static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods); // GLFW3 Keyboard Callback, runs on key pressed
|
|
static void CharCallback(GLFWwindow *window, unsigned int codepoint); // GLFW3 Char Callback, runs on key pressed (get codepoint value)
|
|
static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods); // GLFW3 Mouse Button Callback, runs on mouse button pressed
|
|
static void MouseCursorPosCallback(GLFWwindow *window, double x, double y); // GLFW3 Cursor Position Callback, runs on mouse move
|
|
static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset); // GLFW3 Scrolling Callback, runs on mouse wheel
|
|
static void CursorEnterCallback(GLFWwindow *window, int enter); // GLFW3 Cursor Enter Callback, cursor enters client area
|
|
static void JoystickCallback(int jid, int event); // GLFW3 Joystick Connected/Disconnected Callback
|
|
|
|
// Customized and internal tool functions
|
|
static void _SetupFramebuffer(int frameBufferWidth, int frameBufferHeight, bool inHardwareFullscreenMode); // Better implementation of SetupFramebuffer()
|
|
|
|
static bool _ActivateHardwareFullscreenMode(int monitorIndex, int desiredWidth, int desiredHeight, int desiredRefreshRate);
|
|
static void _DeactivateHardwareFullscreenMode();
|
|
|
|
static void _SetupMouseScaleAndOffset(); // Update mouse scale and offset according to current viewport
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Declaration
|
|
//----------------------------------------------------------------------------------
|
|
// NOTE: Functions declaration is provided by raylib.h
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Definition: Window and Graphics Device
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Check if application should close
|
|
// NOTE: By default, if KEY_ESCAPE pressed or window close icon clicked
|
|
bool WindowShouldClose(void)
|
|
{
|
|
if (CORE.Window.ready) return CORE.Window.shouldClose;
|
|
else return true;
|
|
}
|
|
|
|
|
|
// Toggle fullscreen mode
|
|
void ToggleFullscreen(void)
|
|
{
|
|
if (IsWindowState(FLAG_BORDERLESS_WINDOWED_MODE))
|
|
{
|
|
// We can't go straighforward from one fullscreen mode to an other
|
|
// there needs to be at least one loop between them
|
|
// so we just toggle the currently active fullscreen mode and leave.
|
|
ToggleBorderlessWindowed();
|
|
return;
|
|
}
|
|
|
|
if (!CORE.Window.fullscreen)
|
|
{
|
|
_ActivateHardwareFullscreenMode( GetCurrentMonitor(), CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE );
|
|
}
|
|
else
|
|
{
|
|
_DeactivateHardwareFullscreenMode();
|
|
}
|
|
|
|
// Refocus window
|
|
glfwFocusWindow(platform.handle);
|
|
|
|
// Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS)
|
|
// NOTE: V-Sync can be enabled by graphic driver configuration
|
|
if (CORE.Window.flags & FLAG_VSYNC_HINT) glfwSwapInterval(1);
|
|
}
|
|
|
|
// Toggle borderless windowed mode
|
|
void ToggleBorderlessWindowed(void)
|
|
{
|
|
if (CORE.Window.fullscreen)
|
|
{
|
|
// We can't go straighforward from one fullscreen mode to an other
|
|
// there needs to be at least one loop between them
|
|
// so we just toggle the currently active fullscreen mode and leave.
|
|
ToggleFullscreen();
|
|
return;
|
|
}
|
|
|
|
const int monitor = GetCurrentMonitor();
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
|
|
if (mode)
|
|
{
|
|
TRACELOG(LOG_INFO, "DISPLAY: ToggleBorderlessWindowed before");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Screen scale: %f x %f", CORE.Window.screenScale.m0, CORE.Window.screenScale.m5);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
|
|
if (!IsWindowState(FLAG_BORDERLESS_WINDOWED_MODE))
|
|
{
|
|
// Store screen position and size :
|
|
glfwGetWindowPos(platform.handle, &CORE.Window.previousPosition.x, &CORE.Window.previousPosition.y);
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window
|
|
glfwGetError(NULL); // So we must clear this error
|
|
|
|
//!\ We need to save the frameBuffer size intead of the "screen size"
|
|
|
|
int prevWidth, prevHeight;
|
|
glfwGetFramebufferSize(platform.handle, &prevWidth, &prevHeight);
|
|
|
|
CORE.Window.previousScreen.width = prevWidth;
|
|
CORE.Window.previousScreen.height = prevHeight;
|
|
|
|
// Ask fullscreen window :
|
|
glfwSetWindowMonitor(platform.handle, monitors[monitor], 0, 0, mode->width, mode->height, mode->refreshRate);
|
|
|
|
_SetupFramebuffer( mode->width , mode->height, false );
|
|
|
|
// Refocus window
|
|
glfwFocusWindow(platform.handle);
|
|
|
|
CORE.Window.flags |= FLAG_BORDERLESS_WINDOWED_MODE;
|
|
}
|
|
else
|
|
{
|
|
// Return previous screen size and position
|
|
int prevPosX = CORE.Window.previousPosition.x;
|
|
int prevPosY = CORE.Window.previousPosition.y;
|
|
int prevWidth = CORE.Window.previousScreen.width;
|
|
int prevHeight = CORE.Window.previousScreen.height;
|
|
|
|
glfwSetWindowMonitor(platform.handle, NULL, prevPosX, prevPosY, prevWidth, prevHeight, GLFW_DONT_CARE);
|
|
|
|
if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
|
|
{
|
|
// Apparently, Wayland does not call the resize callback when required ...
|
|
WindowSizeCallback(platform.handle, prevWidth, prevHeight);
|
|
}
|
|
else
|
|
{
|
|
_SetupFramebuffer(prevWidth , prevHeight, false);
|
|
}
|
|
|
|
// Refocus window
|
|
glfwFocusWindow(platform.handle);
|
|
|
|
CORE.Window.flags &= ~FLAG_BORDERLESS_WINDOWED_MODE;
|
|
}
|
|
TRACELOG(LOG_INFO, "DISPLAY: ToggleBorderlessWindowed after");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Screen scale: %f x %f", CORE.Window.screenScale.m0, CORE.Window.screenScale.m5);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
}
|
|
|
|
// Set window state: maximized, if resizable
|
|
void MaximizeWindow(void)
|
|
{
|
|
if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE)
|
|
{
|
|
glfwMaximizeWindow(platform.handle);
|
|
CORE.Window.flags |= FLAG_WINDOW_MAXIMIZED;
|
|
}
|
|
}
|
|
|
|
// Set window state: minimized
|
|
void MinimizeWindow(void)
|
|
{
|
|
// NOTE: Following function launches callback that sets appropriate flag!
|
|
glfwIconifyWindow(platform.handle);
|
|
}
|
|
|
|
// Set window state: not minimized/maximized
|
|
void RestoreWindow(void)
|
|
{
|
|
if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE)
|
|
{
|
|
// Restores the specified window if it was previously iconified (minimized) or maximized
|
|
glfwRestoreWindow(platform.handle);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
|
|
CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
|
|
}
|
|
}
|
|
|
|
// Set window configuration state using flags
|
|
void SetWindowState(unsigned int flags)
|
|
{
|
|
// Check previous state and requested state to apply required changes
|
|
// NOTE: In most cases the functions already change the flags internally
|
|
|
|
// State change: FLAG_VSYNC_HINT
|
|
if (((CORE.Window.flags & FLAG_VSYNC_HINT) != (flags & FLAG_VSYNC_HINT)) && ((flags & FLAG_VSYNC_HINT) > 0))
|
|
{
|
|
glfwSwapInterval(1);
|
|
CORE.Window.flags |= FLAG_VSYNC_HINT;
|
|
}
|
|
|
|
// State change: FLAG_BORDERLESS_WINDOWED_MODE
|
|
// NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
|
|
if (((CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE) != (flags & FLAG_BORDERLESS_WINDOWED_MODE)) && ((flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0))
|
|
{
|
|
ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_FULLSCREEN_MODE
|
|
if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) != (flags & FLAG_FULLSCREEN_MODE))
|
|
{
|
|
ToggleFullscreen(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_RESIZABLE
|
|
if (((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) != (flags & FLAG_WINDOW_RESIZABLE)) && ((flags & FLAG_WINDOW_RESIZABLE) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_TRUE);
|
|
CORE.Window.flags |= FLAG_WINDOW_RESIZABLE;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_UNDECORATED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) != (flags & FLAG_WINDOW_UNDECORATED)) && (flags & FLAG_WINDOW_UNDECORATED))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_FALSE);
|
|
CORE.Window.flags |= FLAG_WINDOW_UNDECORATED;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_HIDDEN
|
|
if (((CORE.Window.flags & FLAG_WINDOW_HIDDEN) != (flags & FLAG_WINDOW_HIDDEN)) && ((flags & FLAG_WINDOW_HIDDEN) > 0))
|
|
{
|
|
glfwHideWindow(platform.handle);
|
|
CORE.Window.flags |= FLAG_WINDOW_HIDDEN;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_MINIMIZED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) != (flags & FLAG_WINDOW_MINIMIZED)) && ((flags & FLAG_WINDOW_MINIMIZED) > 0))
|
|
{
|
|
//GLFW_ICONIFIED
|
|
MinimizeWindow(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_MAXIMIZED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) != (flags & FLAG_WINDOW_MAXIMIZED)) && ((flags & FLAG_WINDOW_MAXIMIZED) > 0))
|
|
{
|
|
//GLFW_MAXIMIZED
|
|
MaximizeWindow(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_UNFOCUSED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) != (flags & FLAG_WINDOW_UNFOCUSED)) && ((flags & FLAG_WINDOW_UNFOCUSED) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_FALSE);
|
|
CORE.Window.flags |= FLAG_WINDOW_UNFOCUSED;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_TOPMOST
|
|
if (((CORE.Window.flags & FLAG_WINDOW_TOPMOST) != (flags & FLAG_WINDOW_TOPMOST)) && ((flags & FLAG_WINDOW_TOPMOST) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_TRUE);
|
|
CORE.Window.flags |= FLAG_WINDOW_TOPMOST;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_ALWAYS_RUN
|
|
if (((CORE.Window.flags & FLAG_WINDOW_ALWAYS_RUN) != (flags & FLAG_WINDOW_ALWAYS_RUN)) && ((flags & FLAG_WINDOW_ALWAYS_RUN) > 0))
|
|
{
|
|
CORE.Window.flags |= FLAG_WINDOW_ALWAYS_RUN;
|
|
}
|
|
|
|
// The following states can not be changed after window creation
|
|
|
|
// State change: FLAG_WINDOW_TRANSPARENT
|
|
if (((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) != (flags & FLAG_WINDOW_TRANSPARENT)) && ((flags & FLAG_WINDOW_TRANSPARENT) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_HIGHDPI
|
|
if (((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) != (flags & FLAG_WINDOW_HIGHDPI)) && ((flags & FLAG_WINDOW_HIGHDPI) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
|
|
if (((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) != (flags & FLAG_WINDOW_MOUSE_PASSTHROUGH)) && ((flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
|
|
CORE.Window.flags |= FLAG_WINDOW_MOUSE_PASSTHROUGH;
|
|
}
|
|
|
|
// State change: FLAG_MSAA_4X_HINT
|
|
if (((CORE.Window.flags & FLAG_MSAA_4X_HINT) != (flags & FLAG_MSAA_4X_HINT)) && ((flags & FLAG_MSAA_4X_HINT) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_INTERLACED_HINT
|
|
if (((CORE.Window.flags & FLAG_INTERLACED_HINT) != (flags & FLAG_INTERLACED_HINT)) && ((flags & FLAG_INTERLACED_HINT) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_RESCALE_CONTENT
|
|
if (((CORE.Window.flags & FLAG_RESCALE_CONTENT) != (flags & FLAG_RESCALE_CONTENT)) && ((flags & FLAG_RESCALE_CONTENT) > 0))
|
|
{
|
|
CORE.Window.flags |= FLAG_RESCALE_CONTENT;
|
|
int fbWidth;
|
|
int fbHeight;
|
|
glfwGetFramebufferSize(platform.handle, &fbWidth, &fbHeight);
|
|
WindowSizeCallback(platform.handle, fbWidth, fbHeight);
|
|
}
|
|
}
|
|
|
|
// Clear window configuration state flags
|
|
void ClearWindowState(unsigned int flags)
|
|
{
|
|
// Check previous state and requested state to apply required changes
|
|
// NOTE: In most cases the functions already change the flags internally
|
|
|
|
// State change: FLAG_VSYNC_HINT
|
|
if (((CORE.Window.flags & FLAG_VSYNC_HINT) > 0) && ((flags & FLAG_VSYNC_HINT) > 0))
|
|
{
|
|
glfwSwapInterval(0);
|
|
CORE.Window.flags &= ~FLAG_VSYNC_HINT;
|
|
}
|
|
|
|
// State change: FLAG_BORDERLESS_WINDOWED_MODE
|
|
// NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
|
|
if (((CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0) && ((flags & FLAG_BORDERLESS_WINDOWED_MODE) > 0))
|
|
{
|
|
ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_FULLSCREEN_MODE
|
|
if (((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) && ((flags & FLAG_FULLSCREEN_MODE) > 0))
|
|
{
|
|
ToggleFullscreen(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_RESIZABLE
|
|
if (((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) && ((flags & FLAG_WINDOW_RESIZABLE) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_FALSE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_RESIZABLE;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_HIDDEN
|
|
if (((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) && ((flags & FLAG_WINDOW_HIDDEN) > 0))
|
|
{
|
|
glfwShowWindow(platform.handle);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_HIDDEN;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_MINIMIZED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) && ((flags & FLAG_WINDOW_MINIMIZED) > 0))
|
|
{
|
|
RestoreWindow(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_MAXIMIZED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) && ((flags & FLAG_WINDOW_MAXIMIZED) > 0))
|
|
{
|
|
RestoreWindow(); // NOTE: Window state flag updated inside function
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_UNDECORATED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) && ((flags & FLAG_WINDOW_UNDECORATED) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_TRUE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_UNDECORATED;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_UNFOCUSED
|
|
if (((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) && ((flags & FLAG_WINDOW_UNFOCUSED) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_TRUE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_UNFOCUSED;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_TOPMOST
|
|
if (((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) && ((flags & FLAG_WINDOW_TOPMOST) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_FALSE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_TOPMOST;
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_ALWAYS_RUN
|
|
if (((CORE.Window.flags & FLAG_WINDOW_ALWAYS_RUN) > 0) && ((flags & FLAG_WINDOW_ALWAYS_RUN) > 0))
|
|
{
|
|
CORE.Window.flags &= ~FLAG_WINDOW_ALWAYS_RUN;
|
|
}
|
|
|
|
// The following states can not be changed after window creation
|
|
|
|
// State change: FLAG_WINDOW_TRANSPARENT
|
|
if (((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) && ((flags & FLAG_WINDOW_TRANSPARENT) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_HIGHDPI
|
|
if (((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0) && ((flags & FLAG_WINDOW_HIGHDPI) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
|
|
if (((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) && ((flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0))
|
|
{
|
|
glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_MOUSE_PASSTHROUGH;
|
|
}
|
|
|
|
// State change: FLAG_MSAA_4X_HINT
|
|
if (((CORE.Window.flags & FLAG_MSAA_4X_HINT) > 0) && ((flags & FLAG_MSAA_4X_HINT) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_INTERLACED_HINT
|
|
if (((CORE.Window.flags & FLAG_INTERLACED_HINT) > 0) && ((flags & FLAG_INTERLACED_HINT) > 0))
|
|
{
|
|
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
|
|
}
|
|
|
|
// State change: FLAG_RESCALE_CONTENT
|
|
if (((CORE.Window.flags & FLAG_RESCALE_CONTENT) > 0) && ((flags & FLAG_RESCALE_CONTENT) > 0))
|
|
{
|
|
CORE.Window.flags &= ~FLAG_RESCALE_CONTENT;
|
|
int fbWidth;
|
|
int fbHeight;
|
|
glfwGetFramebufferSize(platform.handle, &fbWidth, &fbHeight);
|
|
WindowSizeCallback(platform.handle, fbWidth, fbHeight);
|
|
}
|
|
}
|
|
|
|
// Set icon for window
|
|
// NOTE 1: Image must be in RGBA format, 8bit per channel
|
|
// NOTE 2: Image is scaled by the OS for all required sizes
|
|
void SetWindowIcon(Image image)
|
|
{
|
|
if (image.data == NULL)
|
|
{
|
|
// Revert to the default window icon, pass in an empty image array
|
|
glfwSetWindowIcon(platform.handle, 0, NULL);
|
|
}
|
|
else
|
|
{
|
|
if (image.format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
|
|
{
|
|
GLFWimage icon[1] = { 0 };
|
|
|
|
icon[0].width = image.width;
|
|
icon[0].height = image.height;
|
|
icon[0].pixels = (unsigned char *)image.data;
|
|
|
|
// NOTE 1: We only support one image icon
|
|
// NOTE 2: The specified image data is copied before this function returns
|
|
glfwSetWindowIcon(platform.handle, 1, icon);
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Window icon image must be in R8G8B8A8 pixel format");
|
|
}
|
|
}
|
|
|
|
// Set icon for window, multiple images
|
|
// NOTE 1: Images must be in RGBA format, 8bit per channel
|
|
// NOTE 2: The multiple images are used depending on provided sizes
|
|
// Standard Windows icon sizes: 256, 128, 96, 64, 48, 32, 24, 16
|
|
void SetWindowIcons(Image *images, int count)
|
|
{
|
|
if ((images == NULL) || (count <= 0))
|
|
{
|
|
// Revert to the default window icon, pass in an empty image array
|
|
glfwSetWindowIcon(platform.handle, 0, NULL);
|
|
}
|
|
else
|
|
{
|
|
int valid = 0;
|
|
GLFWimage *icons = RL_CALLOC(count, sizeof(GLFWimage));
|
|
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if (images[i].format == PIXELFORMAT_UNCOMPRESSED_R8G8B8A8)
|
|
{
|
|
icons[valid].width = images[i].width;
|
|
icons[valid].height = images[i].height;
|
|
icons[valid].pixels = (unsigned char *)images[i].data;
|
|
|
|
valid++;
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Window icon image must be in R8G8B8A8 pixel format");
|
|
}
|
|
// NOTE: Images data is copied internally before this function returns
|
|
glfwSetWindowIcon(platform.handle, valid, icons);
|
|
|
|
RL_FREE(icons);
|
|
}
|
|
}
|
|
|
|
// Set title for window
|
|
void SetWindowTitle(const char *title)
|
|
{
|
|
CORE.Window.title = title;
|
|
glfwSetWindowTitle(platform.handle, title);
|
|
}
|
|
|
|
// Set window position on screen (windowed mode)
|
|
void SetWindowPosition(int x, int y)
|
|
{
|
|
glfwSetWindowPos(platform.handle, x, y);
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window
|
|
glfwGetError(NULL); // So we must clear this error
|
|
}
|
|
|
|
// Set monitor for the current window
|
|
void SetWindowMonitor(int monitor)
|
|
{
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
bool changingMonitor = (CORE.Window.lastAssociatedMonitorIndex != monitor);
|
|
|
|
CORE.Window.lastAssociatedMonitorIndex = monitor;
|
|
|
|
if ((CORE.Window.fullscreen) || IsWindowState(FLAG_BORDERLESS_WINDOWED_MODE))
|
|
{
|
|
TRACELOG(LOG_INFO, "GLFW: Selected fullscreen monitor: [%i] %s", monitor, glfwGetMonitorName(monitors[monitor]));
|
|
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
glfwSetWindowMonitor(platform.handle, monitors[monitor], 0, 0, mode->width, mode->height, mode->refreshRate);
|
|
}
|
|
else
|
|
if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
|
|
{
|
|
// On current implementation of Wayland and GLFW,
|
|
// this is the only way i found to move the window
|
|
// from one monitor to another :
|
|
|
|
if (changingMonitor && !IsWindowState(FLAG_BORDERLESS_WINDOWED_MODE))
|
|
{
|
|
//!\ TODO FIXME This workaround might causes some unexpected issues and could be improved
|
|
|
|
ToggleBorderlessWindowed(); // The fullscreen window is automatically moved to the monitor
|
|
ToggleBorderlessWindowed(); // and is restored as windowed window on the same monitor.
|
|
}
|
|
}
|
|
else
|
|
{
|
|
TRACELOG(LOG_INFO, "GLFW: Selected monitor: [%i] %s", monitor, glfwGetMonitorName(monitors[monitor]));
|
|
|
|
const int screenWidth = CORE.Window.screen.width;
|
|
const int screenHeight = CORE.Window.screen.height;
|
|
int monitorWorkareaX = 0;
|
|
int monitorWorkareaY = 0;
|
|
int monitorWorkareaWidth = 0;
|
|
int monitorWorkareaHeight = 0;
|
|
glfwGetMonitorWorkarea(monitors[monitor], &monitorWorkareaX, &monitorWorkareaY, &monitorWorkareaWidth, &monitorWorkareaHeight);
|
|
|
|
// If the screen size is larger than the monitor workarea, anchor it on the top left corner, otherwise, center it
|
|
if ((screenWidth >= monitorWorkareaWidth) || (screenHeight >= monitorWorkareaHeight)) glfwSetWindowPos(platform.handle, monitorWorkareaX, monitorWorkareaY);
|
|
else
|
|
{
|
|
const int x = monitorWorkareaX + (monitorWorkareaWidth/2) - (screenWidth/2);
|
|
const int y = monitorWorkareaY + (monitorWorkareaHeight/2) - (screenHeight/2);
|
|
glfwSetWindowPos(platform.handle, x, y);
|
|
}
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window
|
|
glfwGetError(NULL); // So we must clear this error
|
|
|
|
// NOTE : As of current version of Wayland and GLFW, it is not possible to set the position of a windowed
|
|
// window by code, so this fonction will not move it from a display to another. Instead, it will
|
|
// associate a monitor index to the window for fullscreen mode.
|
|
|
|
}
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
}
|
|
|
|
// Set window minimum dimensions (FLAG_WINDOW_RESIZABLE)
|
|
void SetWindowMinSize(int width, int height)
|
|
{
|
|
CORE.Window.screenMin.width = width;
|
|
CORE.Window.screenMin.height = height;
|
|
|
|
int minWidth = (CORE.Window.screenMin.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.width;
|
|
int minHeight = (CORE.Window.screenMin.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.height;
|
|
int maxWidth = (CORE.Window.screenMax.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.width;
|
|
int maxHeight = (CORE.Window.screenMax.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.height;
|
|
|
|
glfwSetWindowSizeLimits(platform.handle, minWidth, minHeight, maxWidth, maxHeight);
|
|
}
|
|
|
|
// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE)
|
|
void SetWindowMaxSize(int width, int height)
|
|
{
|
|
CORE.Window.screenMax.width = width;
|
|
CORE.Window.screenMax.height = height;
|
|
|
|
int minWidth = (CORE.Window.screenMin.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.width;
|
|
int minHeight = (CORE.Window.screenMin.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMin.height;
|
|
int maxWidth = (CORE.Window.screenMax.width == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.width;
|
|
int maxHeight = (CORE.Window.screenMax.height == 0)? GLFW_DONT_CARE : (int)CORE.Window.screenMax.height;
|
|
|
|
glfwSetWindowSizeLimits(platform.handle, minWidth, minHeight, maxWidth, maxHeight);
|
|
}
|
|
|
|
// Set window dimensions
|
|
void SetWindowSize(int width, int height)
|
|
{
|
|
CORE.Window.screen.width = width;
|
|
CORE.Window.screen.height = height;
|
|
|
|
glfwSetWindowSize(platform.handle, width, height);
|
|
}
|
|
|
|
// Set window opacity, value opacity is between 0.0 and 1.0
|
|
void SetWindowOpacity(float opacity)
|
|
{
|
|
if (opacity >= 1.0f) opacity = 1.0f;
|
|
else if (opacity <= 0.0f) opacity = 0.0f;
|
|
glfwSetWindowOpacity(platform.handle, opacity);
|
|
}
|
|
|
|
// Set window focused
|
|
void SetWindowFocused(void)
|
|
{
|
|
glfwFocusWindow(platform.handle);
|
|
}
|
|
|
|
// Get native window handle
|
|
void *GetWindowHandle(void)
|
|
{
|
|
#if defined(_WIN32)
|
|
// NOTE: Returned handle is: void *HWND (windows.h)
|
|
return glfwGetWin32Window(platform.handle);
|
|
#endif
|
|
#if defined(__linux__)
|
|
// NOTE: Returned handle is: unsigned long Window (X.h)
|
|
// typedef unsigned long XID;
|
|
// typedef XID Window;
|
|
//unsigned long id = (unsigned long)glfwGetX11Window(platform.handle);
|
|
//return NULL; // TODO: Find a way to return value... cast to void *?
|
|
return (void *)platform.handle;
|
|
#endif
|
|
#if defined(__APPLE__)
|
|
// NOTE: Returned handle is: (objc_object *)
|
|
return (void *)glfwGetCocoaWindow(platform.handle);
|
|
#endif
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// Get number of monitors
|
|
int GetMonitorCount(void)
|
|
{
|
|
int monitorCount = 0;
|
|
|
|
glfwGetMonitors(&monitorCount);
|
|
|
|
return monitorCount;
|
|
}
|
|
|
|
// Get number of monitors
|
|
int GetCurrentMonitor(void)
|
|
{
|
|
int index = 0;
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
GLFWmonitor *monitor = NULL;
|
|
|
|
if (monitorCount >= 1)
|
|
{
|
|
if (IsWindowFullscreen())
|
|
{
|
|
// Get the handle of the monitor that the specified window is in full screen on
|
|
monitor = glfwGetWindowMonitor(platform.handle);
|
|
|
|
for (int i = 0; i < monitorCount; i++)
|
|
{
|
|
if (monitors[i] == monitor)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
|
|
{
|
|
// The algorithm bellow, which relies on the window position, won't work with current version of Wayland
|
|
// and GLFW, because Wayland does not allow to know the window position.
|
|
// NOTE : this is not a bug in Wayland or GLFW, it is a "feature design" of current version of Wayland.
|
|
|
|
// So intead of computing on which monitor is mostly displayed the window, we return the index of the monitor
|
|
// to which the user wanted to associate the window to using `SetWindowMonitor()` :
|
|
|
|
index = CORE.Window.lastAssociatedMonitorIndex;
|
|
|
|
if ((index < 0) || (index >= monitorCount))
|
|
{
|
|
index = monitorCount - 1;
|
|
|
|
// A monitor was probably unplugged.
|
|
// TODO : add a TRACELOG ?
|
|
|
|
CORE.Window.lastAssociatedMonitorIndex = index;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// In case the window is between two monitors, we use below logic
|
|
// to try to detect the "current monitor" for that window, note that
|
|
// this is probably an overengineered solution for a very side case
|
|
// trying to match SDL behaviour
|
|
|
|
// NOTE : this algorithm won't work with Wayland because it does not allow to know the window position.
|
|
|
|
int closestDist = 0x7FFFFFFF;
|
|
|
|
// Window center position
|
|
int wcx = 0;
|
|
int wcy = 0;
|
|
|
|
glfwGetWindowPos(platform.handle, &wcx, &wcy);
|
|
wcx += (int)CORE.Window.screen.width/2;
|
|
wcy += (int)CORE.Window.screen.height/2;
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window
|
|
glfwGetError(NULL); // So we must clear this error
|
|
|
|
for (int i = 0; i < monitorCount; i++)
|
|
{
|
|
// Monitor top-left position
|
|
int mx = 0;
|
|
int my = 0;
|
|
|
|
monitor = monitors[i];
|
|
glfwGetMonitorPos(monitor, &mx, &my);
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
|
|
|
|
if (mode)
|
|
{
|
|
const int right = mx + mode->width - 1;
|
|
const int bottom = my + mode->height - 1;
|
|
|
|
if ((wcx >= mx) &&
|
|
(wcx <= right) &&
|
|
(wcy >= my) &&
|
|
(wcy <= bottom))
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
|
|
int xclosest = wcx;
|
|
if (wcx < mx) xclosest = mx;
|
|
else if (wcx > right) xclosest = right;
|
|
|
|
int yclosest = wcy;
|
|
if (wcy < my) yclosest = my;
|
|
else if (wcy > bottom) yclosest = bottom;
|
|
|
|
int dx = wcx - xclosest;
|
|
int dy = wcy - yclosest;
|
|
int dist = (dx*dx) + (dy*dy);
|
|
if (dist < closestDist)
|
|
{
|
|
index = i;
|
|
closestDist = dist;
|
|
}
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
|
|
}
|
|
}
|
|
}
|
|
|
|
return index;
|
|
}
|
|
|
|
// Get selected monitor position
|
|
Vector2 GetMonitorPosition(int monitor)
|
|
{
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
int x, y;
|
|
glfwGetMonitorPos(monitors[monitor], &x, &y);
|
|
|
|
return (Vector2){ (float)x, (float)y };
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
return (Vector2){ 0, 0 };
|
|
}
|
|
|
|
// Get selected monitor width (currently used by monitor)
|
|
int GetMonitorWidth(int monitor)
|
|
{
|
|
int width = 0;
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
|
|
if (mode) width = mode->width;
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
|
|
return width;
|
|
}
|
|
|
|
// Get selected monitor height (currently used by monitor)
|
|
int GetMonitorHeight(int monitor)
|
|
{
|
|
int height = 0;
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
|
|
if (mode) height = mode->height;
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
|
|
return height;
|
|
}
|
|
|
|
// Get selected monitor physical width in millimetres
|
|
int GetMonitorPhysicalWidth(int monitor)
|
|
{
|
|
int width = 0;
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount)) glfwGetMonitorPhysicalSize(monitors[monitor], &width, NULL);
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
|
|
return width;
|
|
}
|
|
|
|
// Get selected monitor physical height in millimetres
|
|
int GetMonitorPhysicalHeight(int monitor)
|
|
{
|
|
int height = 0;
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount)) glfwGetMonitorPhysicalSize(monitors[monitor], NULL, &height);
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
|
|
return height;
|
|
}
|
|
|
|
// Get selected monitor refresh rate
|
|
int GetMonitorRefreshRate(int monitor)
|
|
{
|
|
int refresh = 0;
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *vidmode = glfwGetVideoMode(monitors[monitor]);
|
|
refresh = vidmode->refreshRate;
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
|
|
return refresh;
|
|
}
|
|
|
|
// Get the human-readable, UTF-8 encoded name of the selected monitor
|
|
const char *GetMonitorName(int monitor)
|
|
{
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
return glfwGetMonitorName(monitors[monitor]);
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
return "";
|
|
}
|
|
|
|
// Get window position XY on monitor
|
|
Vector2 GetWindowPosition(void)
|
|
{
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
glfwGetWindowPos(platform.handle, &x, &y);
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window
|
|
glfwGetError(NULL); // So we must clear this error
|
|
|
|
return (Vector2){ (float)x, (float)y };
|
|
}
|
|
|
|
// Get window scale DPI factor for current monitor
|
|
Vector2 GetWindowScaleDPI(void)
|
|
{
|
|
Vector2 scale = {1.0, 1.0};
|
|
|
|
// On platforms like Wayland, the window and its frameBuffer are automatically rescaled
|
|
// according to the current DPI scale of the display on which the window is visible,
|
|
// `glfwGetWindowContentScale()` will always return `{1.0, 1.0}`, because there is no need
|
|
// for the application to apply any DPI rescaling by itself.
|
|
// So, to keep consistency between all supported platforms, if `FLAG_WINDOW_HIGHDPI` is enabled
|
|
// we ignore the value returned by `glfwGetWindowContentScale()` and return `{1.0, 1.0}` instead.
|
|
// Same if we are in an hardware/exclusive fullscreen mode.
|
|
|
|
if (!IsWindowState(FLAG_WINDOW_HIGHDPI) && !CORE.Window.fullscreen)
|
|
{
|
|
// We only need to know the DPI scale of the display if we have to rescale our UI and texts manually by code.
|
|
// TODO @SoloByte __APPLE__ test mission
|
|
|
|
glfwGetWindowContentScale(platform.handle, &scale.x, &scale.y);
|
|
}
|
|
|
|
return scale;
|
|
}
|
|
|
|
// Set clipboard text content
|
|
void SetClipboardText(const char *text)
|
|
{
|
|
glfwSetClipboardString(platform.handle, text);
|
|
}
|
|
|
|
// Get clipboard text content
|
|
// NOTE: returned string is allocated and freed by GLFW
|
|
const char *GetClipboardText(void)
|
|
{
|
|
return glfwGetClipboardString(platform.handle);
|
|
}
|
|
|
|
// Show mouse cursor
|
|
void ShowCursor(void)
|
|
{
|
|
glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
|
|
CORE.Input.Mouse.cursorHidden = false;
|
|
}
|
|
|
|
// Hides mouse cursor
|
|
void HideCursor(void)
|
|
{
|
|
glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
|
|
CORE.Input.Mouse.cursorHidden = true;
|
|
}
|
|
|
|
// Enables cursor (unlock cursor)
|
|
void EnableCursor(void)
|
|
{
|
|
glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
|
|
|
|
// Set cursor position in the middle
|
|
SetMousePosition(CORE.Window.screen.width/2, CORE.Window.screen.height/2);
|
|
|
|
if (glfwRawMouseMotionSupported()) glfwSetInputMode(platform.handle, GLFW_RAW_MOUSE_MOTION, GLFW_FALSE);
|
|
|
|
CORE.Input.Mouse.cursorHidden = false;
|
|
}
|
|
|
|
// Disables cursor (lock cursor)
|
|
void DisableCursor(void)
|
|
{
|
|
glfwSetInputMode(platform.handle, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
|
|
|
|
// Set cursor position in the middle
|
|
SetMousePosition(CORE.Window.screen.width/2, CORE.Window.screen.height/2);
|
|
|
|
if (glfwRawMouseMotionSupported()) glfwSetInputMode(platform.handle, GLFW_RAW_MOUSE_MOTION, GLFW_TRUE);
|
|
|
|
CORE.Input.Mouse.cursorHidden = true;
|
|
}
|
|
|
|
// Swap back buffer with front buffer (screen drawing)
|
|
void SwapScreenBuffer(void)
|
|
{
|
|
glfwSwapBuffers(platform.handle);
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Definition: Misc
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Get elapsed time measure in seconds since InitTimer()
|
|
double GetTime(void)
|
|
{
|
|
double time = glfwGetTime(); // Elapsed time since glfwInit()
|
|
return time;
|
|
}
|
|
|
|
// Open URL with default system browser (if available)
|
|
// NOTE: This function is only safe to use if you control the URL given.
|
|
// A user could craft a malicious string performing another action.
|
|
// Only call this function yourself not with user input or make sure to check the string yourself.
|
|
// Ref: https://github.com/raysan5/raylib/issues/686
|
|
void OpenURL(const char *url)
|
|
{
|
|
// Security check to (partially) avoid malicious code
|
|
if (strchr(url, '\'') != NULL) TRACELOG(LOG_WARNING, "SYSTEM: Provided URL could be potentially malicious, avoid [\'] character");
|
|
else
|
|
{
|
|
char *cmd = (char *)RL_CALLOC(strlen(url) + 32, sizeof(char));
|
|
#if defined(_WIN32)
|
|
sprintf(cmd, "explorer \"%s\"", url);
|
|
#endif
|
|
#if defined(__linux__) || defined(__FreeBSD__) || defined(__OpenBSD__)
|
|
sprintf(cmd, "xdg-open '%s'", url); // Alternatives: firefox, x-www-browser
|
|
#endif
|
|
#if defined(__APPLE__)
|
|
sprintf(cmd, "open '%s'", url);
|
|
#endif
|
|
int result = system(cmd);
|
|
if (result == -1) TRACELOG(LOG_WARNING, "OpenURL() child process could not be created");
|
|
RL_FREE(cmd);
|
|
}
|
|
}
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Functions Definition: Inputs
|
|
//----------------------------------------------------------------------------------
|
|
|
|
// Set internal gamepad mappings
|
|
int SetGamepadMappings(const char *mappings)
|
|
{
|
|
return glfwUpdateGamepadMappings(mappings);
|
|
}
|
|
|
|
// Set gamepad vibration
|
|
void SetGamepadVibration(int gamepad, float leftMotor, float rightMotor)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GamepadSetVibration() not available on target platform");
|
|
}
|
|
|
|
// Set mouse position XY
|
|
void SetMousePosition(int x, int y)
|
|
{
|
|
CORE.Input.Mouse.currentPosition = (Vector2){ (float)x, (float)y };
|
|
CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
|
|
|
|
// NOTE: emscripten not implemented
|
|
glfwSetCursorPos(platform.handle, CORE.Input.Mouse.currentPosition.x, CORE.Input.Mouse.currentPosition.y);
|
|
}
|
|
|
|
// Set mouse cursor
|
|
void SetMouseCursor(int cursor)
|
|
{
|
|
CORE.Input.Mouse.cursor = cursor;
|
|
if (cursor == MOUSE_CURSOR_DEFAULT) glfwSetCursor(platform.handle, NULL);
|
|
else
|
|
{
|
|
// NOTE: We are relating internal GLFW enum values to our MouseCursor enum values
|
|
glfwSetCursor(platform.handle, glfwCreateStandardCursor(0x00036000 + cursor));
|
|
}
|
|
}
|
|
|
|
// Get physical key name.
|
|
const char *GetKeyName(int key)
|
|
{
|
|
return glfwGetKeyName(key, glfwGetKeyScancode(key));
|
|
}
|
|
|
|
// Register all input events
|
|
void PollInputEvents(void)
|
|
{
|
|
#if defined(SUPPORT_GESTURES_SYSTEM)
|
|
// NOTE: Gestures update must be called every frame to reset gestures correctly
|
|
// because ProcessGestureEvent() is just called on an event, not every frame
|
|
UpdateGestures();
|
|
#endif
|
|
|
|
// Reset keys/chars pressed registered
|
|
CORE.Input.Keyboard.keyPressedQueueCount = 0;
|
|
CORE.Input.Keyboard.charPressedQueueCount = 0;
|
|
|
|
// Reset last gamepad button/axis registered state
|
|
CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
|
|
//CORE.Input.Gamepad.axisCount = 0;
|
|
|
|
// Keyboard/Mouse input polling (automatically managed by GLFW3 through callback)
|
|
|
|
// Register previous keys states
|
|
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++)
|
|
{
|
|
CORE.Input.Keyboard.previousKeyState[i] = CORE.Input.Keyboard.currentKeyState[i];
|
|
CORE.Input.Keyboard.keyRepeatInFrame[i] = 0;
|
|
}
|
|
|
|
// Register previous mouse states
|
|
for (int i = 0; i < MAX_MOUSE_BUTTONS; i++) CORE.Input.Mouse.previousButtonState[i] = CORE.Input.Mouse.currentButtonState[i];
|
|
|
|
// Register previous mouse wheel state
|
|
CORE.Input.Mouse.previousWheelMove = CORE.Input.Mouse.currentWheelMove;
|
|
CORE.Input.Mouse.currentWheelMove = (Vector2){ 0.0f, 0.0f };
|
|
|
|
// Register previous mouse position
|
|
CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
|
|
|
|
// Register previous touch states
|
|
for (int i = 0; i < MAX_TOUCH_POINTS; i++) CORE.Input.Touch.previousTouchState[i] = CORE.Input.Touch.currentTouchState[i];
|
|
|
|
// Reset touch positions
|
|
//for (int i = 0; i < MAX_TOUCH_POINTS; i++) CORE.Input.Touch.position[i] = (Vector2){ 0, 0 };
|
|
|
|
// Map touch position to mouse position for convenience
|
|
// WARNING: If the target desktop device supports touch screen, this behaviour should be reviewed!
|
|
// TODO: GLFW does not support multi-touch input just yet
|
|
// https://www.codeproject.com/Articles/668404/Programming-for-Multi-Touch
|
|
// https://docs.microsoft.com/en-us/windows/win32/wintouch/getting-started-with-multi-touch-messages
|
|
CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
|
|
|
|
// Check if gamepads are ready
|
|
// NOTE: We do it here in case of disconnection
|
|
for (int i = 0; i < MAX_GAMEPADS; i++)
|
|
{
|
|
if (glfwJoystickPresent(i)) CORE.Input.Gamepad.ready[i] = true;
|
|
else CORE.Input.Gamepad.ready[i] = false;
|
|
}
|
|
|
|
// Register gamepads buttons events
|
|
for (int i = 0; i < MAX_GAMEPADS; i++)
|
|
{
|
|
if (CORE.Input.Gamepad.ready[i]) // Check if gamepad is available
|
|
{
|
|
// Register previous gamepad states
|
|
for (int k = 0; k < MAX_GAMEPAD_BUTTONS; k++) CORE.Input.Gamepad.previousButtonState[i][k] = CORE.Input.Gamepad.currentButtonState[i][k];
|
|
|
|
// Get current gamepad state
|
|
// NOTE: There is no callback available, so we get it manually
|
|
GLFWgamepadstate state = { 0 };
|
|
glfwGetGamepadState(i, &state); // This remapps all gamepads so they have their buttons mapped like an xbox controller
|
|
|
|
const unsigned char *buttons = state.buttons;
|
|
|
|
for (int k = 0; (buttons != NULL) && (k < MAX_GAMEPAD_BUTTONS); k++)
|
|
{
|
|
int button = -1; // GamepadButton enum values assigned
|
|
|
|
switch (k)
|
|
{
|
|
case GLFW_GAMEPAD_BUTTON_Y: button = GAMEPAD_BUTTON_RIGHT_FACE_UP; break;
|
|
case GLFW_GAMEPAD_BUTTON_B: button = GAMEPAD_BUTTON_RIGHT_FACE_RIGHT; break;
|
|
case GLFW_GAMEPAD_BUTTON_A: button = GAMEPAD_BUTTON_RIGHT_FACE_DOWN; break;
|
|
case GLFW_GAMEPAD_BUTTON_X: button = GAMEPAD_BUTTON_RIGHT_FACE_LEFT; break;
|
|
|
|
case GLFW_GAMEPAD_BUTTON_LEFT_BUMPER: button = GAMEPAD_BUTTON_LEFT_TRIGGER_1; break;
|
|
case GLFW_GAMEPAD_BUTTON_RIGHT_BUMPER: button = GAMEPAD_BUTTON_RIGHT_TRIGGER_1; break;
|
|
|
|
case GLFW_GAMEPAD_BUTTON_BACK: button = GAMEPAD_BUTTON_MIDDLE_LEFT; break;
|
|
case GLFW_GAMEPAD_BUTTON_GUIDE: button = GAMEPAD_BUTTON_MIDDLE; break;
|
|
case GLFW_GAMEPAD_BUTTON_START: button = GAMEPAD_BUTTON_MIDDLE_RIGHT; break;
|
|
|
|
case GLFW_GAMEPAD_BUTTON_DPAD_UP: button = GAMEPAD_BUTTON_LEFT_FACE_UP; break;
|
|
case GLFW_GAMEPAD_BUTTON_DPAD_RIGHT: button = GAMEPAD_BUTTON_LEFT_FACE_RIGHT; break;
|
|
case GLFW_GAMEPAD_BUTTON_DPAD_DOWN: button = GAMEPAD_BUTTON_LEFT_FACE_DOWN; break;
|
|
case GLFW_GAMEPAD_BUTTON_DPAD_LEFT: button = GAMEPAD_BUTTON_LEFT_FACE_LEFT; break;
|
|
|
|
case GLFW_GAMEPAD_BUTTON_LEFT_THUMB: button = GAMEPAD_BUTTON_LEFT_THUMB; break;
|
|
case GLFW_GAMEPAD_BUTTON_RIGHT_THUMB: button = GAMEPAD_BUTTON_RIGHT_THUMB; break;
|
|
default: break;
|
|
}
|
|
|
|
if (button != -1) // Check for valid button
|
|
{
|
|
if (buttons[k] == GLFW_PRESS)
|
|
{
|
|
CORE.Input.Gamepad.currentButtonState[i][button] = 1;
|
|
CORE.Input.Gamepad.lastButtonPressed = button;
|
|
}
|
|
else CORE.Input.Gamepad.currentButtonState[i][button] = 0;
|
|
}
|
|
}
|
|
|
|
// Get current axis state
|
|
const float *axes = state.axes;
|
|
|
|
for (int k = 0; (axes != NULL) && (k < GLFW_GAMEPAD_AXIS_LAST + 1); k++)
|
|
{
|
|
CORE.Input.Gamepad.axisState[i][k] = axes[k];
|
|
}
|
|
|
|
// Register buttons for 2nd triggers (because GLFW doesn't count these as buttons but rather axis)
|
|
CORE.Input.Gamepad.currentButtonState[i][GAMEPAD_BUTTON_LEFT_TRIGGER_2] = (char)(CORE.Input.Gamepad.axisState[i][GAMEPAD_AXIS_LEFT_TRIGGER] > 0.1f);
|
|
CORE.Input.Gamepad.currentButtonState[i][GAMEPAD_BUTTON_RIGHT_TRIGGER_2] = (char)(CORE.Input.Gamepad.axisState[i][GAMEPAD_AXIS_RIGHT_TRIGGER] > 0.1f);
|
|
|
|
CORE.Input.Gamepad.axisCount[i] = GLFW_GAMEPAD_AXIS_LAST + 1;
|
|
}
|
|
}
|
|
|
|
CORE.Window.resizedLastFrame = false;
|
|
|
|
if (CORE.Window.eventWaiting) glfwWaitEvents(); // Wait for in input events before continue (drawing is paused)
|
|
else glfwPollEvents(); // Poll input events: keyboard/mouse/window events (callbacks) -> Update keys state
|
|
|
|
// While window minimized, stop loop execution
|
|
while (IsWindowState(FLAG_WINDOW_MINIMIZED) && !IsWindowState(FLAG_WINDOW_ALWAYS_RUN)) glfwWaitEvents();
|
|
|
|
CORE.Window.shouldClose = glfwWindowShouldClose(platform.handle);
|
|
|
|
// Reset close status for next frame
|
|
glfwSetWindowShouldClose(platform.handle, GLFW_FALSE);
|
|
}
|
|
|
|
|
|
//----------------------------------------------------------------------------------
|
|
// Module Internal Functions Definition
|
|
//----------------------------------------------------------------------------------
|
|
|
|
|
|
// Initialize platform: graphics, inputs and more
|
|
int InitPlatform(void)
|
|
{
|
|
glfwSetErrorCallback(ErrorCallback);
|
|
/*
|
|
// TODO: Setup GLFW custom allocators to match raylib ones
|
|
const GLFWallocator allocator = {
|
|
.allocate = MemAlloc,
|
|
.deallocate = MemFree,
|
|
.reallocate = MemRealloc,
|
|
.user = NULL
|
|
};
|
|
|
|
glfwInitAllocator(&allocator);
|
|
*/
|
|
|
|
#if defined(__APPLE__)
|
|
glfwInitHint(GLFW_COCOA_CHDIR_RESOURCES, GLFW_FALSE);
|
|
#endif
|
|
// Initialize GLFW internal global state
|
|
int result = glfwInit();
|
|
if (result == GLFW_FALSE) { TRACELOG(LOG_WARNING, "GLFW: Failed to initialize GLFW"); return -1; }
|
|
|
|
// Initialize graphic device: display/window and graphic context
|
|
//----------------------------------------------------------------------------
|
|
glfwDefaultWindowHints(); // Set default windows hints
|
|
//glfwWindowHint(GLFW_RED_BITS, 8); // Framebuffer red color component bits
|
|
//glfwWindowHint(GLFW_GREEN_BITS, 8); // Framebuffer green color component bits
|
|
//glfwWindowHint(GLFW_BLUE_BITS, 8); // Framebuffer blue color component bits
|
|
//glfwWindowHint(GLFW_ALPHA_BITS, 8); // Framebuffer alpha color component bits
|
|
//glfwWindowHint(GLFW_DEPTH_BITS, 24); // Depthbuffer bits
|
|
//glfwWindowHint(GLFW_REFRESH_RATE, 0); // Refresh rate for fullscreen window
|
|
//glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_API); // OpenGL API to use. Alternative: GLFW_OPENGL_ES_API
|
|
//glfwWindowHint(GLFW_AUX_BUFFERS, 0); // Number of auxiliar buffers
|
|
|
|
// Check window creation flags
|
|
if ((CORE.Window.flags & FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true;
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window
|
|
else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_UNDECORATED) > 0) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window
|
|
else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_RESIZABLE) > 0) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window
|
|
else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable
|
|
|
|
// Disable FLAG_WINDOW_MINIMIZED, not supported on initialization
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
|
|
|
|
// Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0) CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) > 0) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
|
|
else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_TOPMOST) > 0) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
|
|
else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
|
|
|
|
// NOTE: Some GLFW flags are not supported on HTML5
|
|
if ((CORE.Window.flags & FLAG_WINDOW_TRANSPARENT) > 0) glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); // Transparent framebuffer
|
|
else glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_FALSE); // Opaque framebuffer
|
|
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
// When the DPI of the monitor on which the window is displayed is changed,
|
|
// the hint bellow ask GLFW to resize the window accordingly to the DPI :
|
|
|
|
glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); // Only has effect on Windows and X11
|
|
|
|
// The hints bellow ask GLFW to resize the frameBuffer accordingly to the DPI.
|
|
// It only has effet MacOS and Wayland.
|
|
|
|
glfwWindowHint(GLFW_SCALE_FRAMEBUFFER, GLFW_FALSE); // Wayland needs it to be false
|
|
// TODO @SoloByte __APPLE__ test mission
|
|
|
|
if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
|
|
{
|
|
// On Wayland, `FLAG_WINDOW_HIGHDPI` must have no effect because the window and its framebuffer are
|
|
// automatically rescaled by the OS. So, instead of rewriting the pipeline to add a Wayland special case
|
|
// everywhere this flag is involved, we just disable it from here so it has no more effect afterward.
|
|
CORE.Window.flags &= ~FLAG_WINDOW_HIGHDPI;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
|
|
glfwWindowHint(GLFW_SCALE_FRAMEBUFFER, GLFW_FALSE); // Wayland needs it to be false
|
|
// TODO @SoloByte __APPLE__ test mission
|
|
}
|
|
|
|
// Mouse passthrough
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0)
|
|
{
|
|
glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
|
|
}
|
|
else
|
|
{
|
|
glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
|
|
}
|
|
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
|
|
{
|
|
// NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs
|
|
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
|
|
glfwWindowHint(GLFW_SAMPLES, 4); // Tries to enable multisampling x4 (MSAA), default is 0
|
|
}
|
|
|
|
// NOTE: When asking for an OpenGL context version, most drivers provide the highest supported version
|
|
// with backward compatibility to older OpenGL versions.
|
|
// For example, if using OpenGL 1.1, driver can provide a 4.3 backwards compatible context.
|
|
|
|
// Check selection OpenGL version
|
|
if (rlGetVersion() == RL_OPENGL_21)
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2); // Choose OpenGL major version (just hint)
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 1); // Choose OpenGL minor version (just hint)
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_33)
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3); // Choose OpenGL major version (just hint)
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); // Profiles Hint: Only 3.3 and above!
|
|
// Values: GLFW_OPENGL_CORE_PROFILE, GLFW_OPENGL_ANY_PROFILE, GLFW_OPENGL_COMPAT_PROFILE
|
|
#if defined(__APPLE__)
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_TRUE); // OSX Requires forward compatibility
|
|
#else
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE); // Forward Compatibility Hint: Only 3.3 and above!
|
|
#endif
|
|
//glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Request OpenGL DEBUG context
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_43)
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); // Choose OpenGL major version (just hint)
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3); // Choose OpenGL minor version (just hint)
|
|
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
|
|
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GLFW_FALSE);
|
|
#if defined(RLGL_ENABLE_OPENGL_DEBUG_CONTEXT)
|
|
glfwWindowHint(GLFW_OPENGL_DEBUG_CONTEXT, GLFW_TRUE); // Enable OpenGL Debug Context
|
|
#endif
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_ES_20) // Request OpenGL ES 2.0 context
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 2);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
|
|
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
|
|
}
|
|
else if (rlGetVersion() == RL_OPENGL_ES_30) // Request OpenGL ES 3.0 context
|
|
{
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
|
|
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 0);
|
|
glfwWindowHint(GLFW_CLIENT_API, GLFW_OPENGL_ES_API);
|
|
glfwWindowHint(GLFW_CONTEXT_CREATION_API, GLFW_EGL_CONTEXT_API);
|
|
}
|
|
|
|
// NOTE: GLFW 3.4+ defers initialization of the Joystick subsystem on the first call to any Joystick related functions.
|
|
// Forcing this initialization here avoids doing it on PollInputEvents() called by EndDrawing() after first frame has been just drawn.
|
|
// The initialization will still happen and possible delays still occur, but before the window is shown, which is a nicer experience.
|
|
// REF: https://github.com/raysan5/raylib/issues/1554
|
|
glfwSetJoystickCallback(NULL);
|
|
|
|
|
|
// Window creation :
|
|
//-----------------------------------
|
|
|
|
// For the sake of code readability, we're going to establish a boolean vocabulary :
|
|
|
|
bool requestWindowHDPI = (CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0;
|
|
|
|
bool requestVsync = (CORE.Window.flags & FLAG_VSYNC_HINT) > 0;
|
|
|
|
bool invalidWindowSizeRequested = (CORE.Window.screen.width <= 0) || (CORE.Window.screen.height <= 0);
|
|
|
|
// In the original source code `InitWindow(0,0)` was interpreted as a request
|
|
// for "windowed fullscreen mode" which is also triggered by `FLAG_BORDERLESS_WINDOWED_MODE`.
|
|
// We replicate this behavior to keep backward compatibility.
|
|
// So if the requested window size is invalid, it is considered a "Borderless windowed" fullscreen mode.
|
|
|
|
bool requestBorderlessWindowed = invalidWindowSizeRequested || (CORE.Window.flags & FLAG_BORDERLESS_WINDOWED_MODE);
|
|
bool requestHardwareFullscreen = CORE.Window.fullscreen ;
|
|
|
|
bool requestWindowedWindow = !requestBorderlessWindowed && !requestHardwareFullscreen;
|
|
|
|
// We can't have both fullscreen modes requested at the same time so we have to make a choice :
|
|
|
|
if (requestBorderlessWindowed && requestHardwareFullscreen)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: both fullscreen modes were requested. Ignoring `FLAG_FULLSCREEN_MODE`.");
|
|
|
|
requestHardwareFullscreen = false ; // update the boolean vocabulary
|
|
|
|
// And let's not forget to update the real flags :
|
|
CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
|
|
CORE.Window.fullscreen = false ;
|
|
}
|
|
|
|
// By default, when a fullscreen window loses focus, GLFW iconifies it and restores the desktop monitor resolution.
|
|
// This default behavior can be emulated on user's side with a simple code : `if ( ! IsWindowFocused() ) MinimizeWindow();`
|
|
// So we disable this GLFW default behavior and let the user decides by themself the behavior of their program,
|
|
// because they may want their fullscreen program to remain visible while interacting with other application on
|
|
// a secondary monitor.
|
|
|
|
glfwWindowHint(GLFW_AUTO_ICONIFY, GLFW_FALSE);
|
|
|
|
// Even if a fullscreen mode is requested, for now we will just open a windowed window with a minimal size.
|
|
// Next, this initial window will be resized and positionned according to what it should be restored to if the user toggles from fullscreen.
|
|
// Once the window fully ready, we will toggle the requested fullscreen mode.
|
|
// NOTE : this means the hardware fullscreen will occurs on the same display than the window will be displayed on.
|
|
// TODO : make it possible to request a hardware fullscreen resolution bigger than current monitor display resolution.
|
|
|
|
int frameBufferWidth = 100 ;
|
|
int frameBufferHeight = 100 ;
|
|
|
|
// Now let's create the window :
|
|
|
|
const char *windowTitle = (CORE.Window.title != 0) ? CORE.Window.title : " ";
|
|
|
|
platform.handle = glfwCreateWindow(frameBufferWidth, frameBufferHeight, windowTitle, NULL, NULL);
|
|
|
|
if (platform.handle == NULL)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to initialize Window");
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
|
|
// Now that the window is created, we can determine on which monitor it was assigned to
|
|
// and derive other missing metrics from the configuration of the display :
|
|
// NOTE : we can't use glfwGetWindowMonitor() directly because it only works if the window is
|
|
// already in hardware fullscreen mode, otherwise it returns NULL. So we use `GetCurrentMonitor()`.
|
|
|
|
if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
|
|
{
|
|
// On current version of Wayland and GLFW it is not possible to know on which monitor the window
|
|
// is mostly visible onto. On some distro, the window will just open on the monitor with the mouse cursor.
|
|
// Unfortunately, the mouse coordinates returned by GLFW are always relative to the top left corner of the
|
|
// window frameBuffer. It is thus impossible to guess on which monitor the window was opened.
|
|
// So we pretend it was on the main monitor, because it is the most common scenario.
|
|
// It is thus possible to associate an other monitor to the window afterward using `SetWindowMonitor()`.
|
|
// However, this association will only have an effect when toggling the window to hardware fullscreen mode.
|
|
|
|
CORE.Window.lastAssociatedMonitorIndex = 0;
|
|
}
|
|
else
|
|
{
|
|
CORE.Window.lastAssociatedMonitorIndex = GetCurrentMonitor();
|
|
}
|
|
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if (CORE.Window.lastAssociatedMonitorIndex >= monitorCount)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to determine Monitor to center Window");
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
|
|
GLFWmonitor *monitor = monitors[CORE.Window.lastAssociatedMonitorIndex];
|
|
|
|
// We got the monitor, now let's get its current video mode :
|
|
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
|
|
|
|
if (mode == NULL)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to get Monitor video mode");
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
|
|
// Now we can update all the missing metrics :
|
|
|
|
CORE.Window.display.width = mode->width;
|
|
CORE.Window.display.height = mode->height;
|
|
|
|
if (invalidWindowSizeRequested)
|
|
{
|
|
// For backward compatibility purpose, an invalid window size is interpreted as a requestBorderlessWindowed.
|
|
// The `FLAG_BORDERLESS_WINDOWED_MODE` flag will be set when `ToggleBorderlessWindowed()` will be called later
|
|
// once we're done setting up the window.
|
|
// For now, we must give an arbitrary valid size to this window.
|
|
// This is the size the window will have if restored from fullscreen mode.
|
|
|
|
CORE.Window.screen.width = mode->width*3/4;
|
|
CORE.Window.screen.height = mode->height*3/4;
|
|
}
|
|
|
|
// If the user did not requestWindowHDPI, the size of the frameBuffer is the same as the requested screen size :
|
|
|
|
frameBufferWidth = CORE.Window.screen.width;
|
|
frameBufferHeight = CORE.Window.screen.height;
|
|
|
|
CORE.Window.currentFbo.width = frameBufferWidth;
|
|
CORE.Window.currentFbo.height = frameBufferHeight;
|
|
|
|
// If the user requestWindowHDPI scaling, we must update the size of the initial frameBuffer.
|
|
|
|
if (requestWindowHDPI)
|
|
{
|
|
|
|
float dpiScaleX, dpiScaleY;
|
|
glfwGetWindowContentScale(platform.handle, &dpiScaleX, &dpiScaleY);
|
|
|
|
// TODO : take `__APPLE__` special case into account. @SoloByte mission (don't forget to give a look at `_SetupFramebuffer()` just in case the special case is already managed there)
|
|
// TODO : take Wayland special case into account. (don't forget to give a look at `_SetupFramebuffer()` just in case the special case is already managed there)
|
|
// TODO : take `FLAG_RESCALE_CONTENT` into account ? (don't forget to give a look at `_SetupFramebuffer()` just in case the special case is
|
|
|
|
frameBufferWidth = (int)roundf((float)frameBufferWidth*dpiScaleX);
|
|
frameBufferHeight = (int)roundf((float)frameBufferHeight*dpiScaleY);
|
|
}
|
|
|
|
// Now that we have the correct frameBuffer size, we can resize the window :
|
|
|
|
glfwSetWindowSize(platform.handle, frameBufferWidth, frameBufferHeight);
|
|
|
|
// We are also ready to recompute all the involved metrics using known `CORE.Window.screen` and frameBuffer sizes :
|
|
|
|
_SetupFramebuffer(frameBufferWidth, frameBufferHeight, false); //!\ We're still in windowed mode for now, so the 3rd argument is `false`
|
|
|
|
// Even if the user requested a fullscreen mode, we're still in windowed mode for now.
|
|
// We will toggle to the requested fullscreen mode once we will be done setting
|
|
// the window as it should be restored if the user decide to leave the fullscreen
|
|
// mode afterward.
|
|
|
|
// So let's try to center it on the desktop :
|
|
|
|
int monitorX = 0;
|
|
int monitorY = 0;
|
|
int monitorWidth = 0;
|
|
int monitorHeight = 0;
|
|
glfwGetMonitorWorkarea(monitor, &monitorX, &monitorY, &monitorWidth, &monitorHeight);
|
|
|
|
int posX = monitorX + (monitorWidth - frameBufferWidth)/2;
|
|
int posY = monitorY + (monitorHeight - frameBufferHeight)/2;
|
|
|
|
// If the frameBuffer was larger than the desktop area, we offset its position :
|
|
if (posX < monitorX) posX = monitorX;
|
|
if (posY < monitorY) posY = monitorY;
|
|
|
|
glfwSetWindowPos(platform.handle, posX, posY); //!\ NOTE : This function sets the position of the upper-left corner
|
|
// of the content area (aka the "frameBuffer") and not the
|
|
// upper-left corner of the window's decoration.
|
|
// This means that the desktop manager or GLFW might not be
|
|
// able to fullfil this request and might change the position.
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window
|
|
glfwGetError(NULL); // So we must clear this error
|
|
|
|
// As our windowed window is almost ready, we can associate the OpenGL context to it :
|
|
|
|
glfwMakeContextCurrent(platform.handle); // NOTE : from here, we must `glfwDestroyWindow()` before any `glfwTerminate()`
|
|
|
|
result = glfwGetError(NULL);
|
|
|
|
if (result != GLFW_NO_ERROR)
|
|
{
|
|
TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphics device");
|
|
glfwDestroyWindow(platform.handle);
|
|
glfwTerminate();
|
|
return -1;
|
|
}
|
|
|
|
// From here, we should have a working windowed window with a working OpenGL context :
|
|
|
|
CORE.Window.ready = true;
|
|
|
|
// Activate V-Sync if requested :
|
|
//--------------------------------------------------------------------------
|
|
|
|
glfwSwapInterval(0); // No V-Sync by default
|
|
|
|
// Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS)
|
|
// NOTE: V-Sync can be enabled by graphic driver configuration, it doesn't need
|
|
// to be activated on web platforms since VSync is enforced there.
|
|
if (requestVsync)
|
|
{
|
|
// WARNING: It seems to hit a critical render path in Intel HD Graphics
|
|
glfwSwapInterval(1);
|
|
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable VSYNC");
|
|
}
|
|
|
|
|
|
// Complete platform intialization :
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Load OpenGL extensions
|
|
// NOTE: GL procedures address loader is required to load extensions
|
|
rlLoadExtensions(glfwGetProcAddress);
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Initialize input events callbacks
|
|
//----------------------------------------------------------------------------
|
|
// Set window callback events
|
|
glfwSetWindowSizeCallback(platform.handle, WindowSizeCallback); // NOTE: Resizing not allowed by default!
|
|
glfwSetWindowMaximizeCallback(platform.handle, WindowMaximizeCallback);
|
|
glfwSetWindowIconifyCallback(platform.handle, WindowIconifyCallback);
|
|
glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback);
|
|
glfwSetDropCallback(platform.handle, WindowDropCallback);
|
|
|
|
#if defined(_WIN32)
|
|
// On Windows 11, in multi-monitor setups, each display might have
|
|
// its own DPI scaling. When moving ANY window (including Calc.exe)
|
|
// from one monitor to another, it appears that Windows 11 resizes
|
|
// this window according to the DPI scaling of the destination display.
|
|
// This also affects when toggle from fullscreen to windowed mode
|
|
// multiple time.
|
|
// This behavior interferes with the current pipeline, and could
|
|
// triggers some tiny changes in screen and render sizes that could
|
|
// surprise the user or the developper.
|
|
// Unfortunately, I could not find any standard solution to disable
|
|
// this behavior. So, for now, it will be a "can't fix".
|
|
|
|
// TODO FIXME : find which version of Windows are affected ?
|
|
// TODO FIXME : find a way to disable this behavior using a GLFW ?
|
|
// TODO FIXME : find a way to disable this behavior using a Win32 API call ?
|
|
|
|
// We enable the callback just to help the programmer notice the TRACELOG
|
|
// triggered by the change of scale, which may lead them to this instructive
|
|
// comment.
|
|
// NOTE : WindowContentScaleCallback() is not expected to do anything
|
|
// beside triggering a TRACELOG.
|
|
|
|
glfwSetWindowContentScaleCallback(platform.handle, WindowContentScaleCallback);
|
|
|
|
#else
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
glfwSetWindowContentScaleCallback(platform.handle, WindowContentScaleCallback);
|
|
}
|
|
#endif
|
|
|
|
// Set input callback events
|
|
glfwSetKeyCallback(platform.handle, KeyCallback);
|
|
glfwSetCharCallback(platform.handle, CharCallback);
|
|
glfwSetMouseButtonCallback(platform.handle, MouseButtonCallback);
|
|
glfwSetCursorPosCallback(platform.handle, MouseCursorPosCallback); // Track mouse position changes
|
|
glfwSetScrollCallback(platform.handle, MouseScrollCallback);
|
|
glfwSetCursorEnterCallback(platform.handle, CursorEnterCallback);
|
|
glfwSetJoystickCallback(JoystickCallback);
|
|
|
|
glfwSetInputMode(platform.handle, GLFW_LOCK_KEY_MODS, GLFW_TRUE); // Enable lock keys modifiers (CAPS, NUM)
|
|
|
|
// Retrieve gamepad names
|
|
for (int i = 0; i < MAX_GAMEPADS; i++)
|
|
{
|
|
if (glfwJoystickPresent(i)) strcpy(CORE.Input.Gamepad.name[i], glfwGetJoystickName(i));
|
|
}
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Initialize timming system
|
|
//----------------------------------------------------------------------------
|
|
InitTimer();
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Initialize storage system
|
|
//----------------------------------------------------------------------------
|
|
CORE.Storage.basePath = GetWorkingDirectory();
|
|
//----------------------------------------------------------------------------
|
|
|
|
#if defined(__NetBSD__)
|
|
// Workaround for NetBSD
|
|
char *glfwPlatform = "X11";
|
|
#else
|
|
char *glfwPlatform = "";
|
|
switch (glfwGetPlatform())
|
|
{
|
|
case GLFW_PLATFORM_WIN32: glfwPlatform = "Win32"; break;
|
|
case GLFW_PLATFORM_COCOA: glfwPlatform = "Cocoa"; break;
|
|
case GLFW_PLATFORM_WAYLAND: glfwPlatform = "Wayland"; break;
|
|
case GLFW_PLATFORM_X11: glfwPlatform = "X11"; break;
|
|
case GLFW_PLATFORM_NULL: glfwPlatform = "Null"; break;
|
|
}
|
|
#endif
|
|
|
|
//
|
|
// Activate fullscreen mode if it was requested
|
|
//----------------------------------------------------------------------------
|
|
|
|
// Now that we have our callbacks ready, we can safely rely on them to apply the appropriate
|
|
|
|
if (requestWindowedWindow)
|
|
{
|
|
// We need to call the resize callback at least once
|
|
WindowSizeCallback(platform.handle, frameBufferWidth, frameBufferHeight);
|
|
}
|
|
else
|
|
if (requestBorderlessWindowed)
|
|
{
|
|
// Before being able to call ToggleBorderlessWindowed()
|
|
// we must unset this flag it was explicitely set
|
|
// otherwise ToggleBorderlessWindowed() will beleive it is
|
|
// already in windowed fullscreen mode.
|
|
CORE.Window.flags &= ~FLAG_BORDERLESS_WINDOWED_MODE;
|
|
ToggleBorderlessWindowed();
|
|
}
|
|
else
|
|
if (requestHardwareFullscreen)
|
|
{
|
|
// We don't use `ToggleFullscreen()` directly because `CORE.Window.fullscreen` is already set to `true`,
|
|
// and `ToggleFullscreen()` would think it is already in fullscreen mode.
|
|
|
|
bool _result = _ActivateHardwareFullscreenMode(CORE.Window.lastAssociatedMonitorIndex, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
|
|
if ( _result == false )
|
|
{
|
|
TRACELOG(LOG_WARNING,"DISPLAY: failed to activate fullscreen mode.");
|
|
// We don't close the window, nor terminate GLFW, nor interrupt the paltform intialization because it is just a warning.
|
|
// The user should still be able to use and access the window in windowed mode.
|
|
// TODO : see with @raysan5 how to formalize the returned error codes.
|
|
|
|
CORE.Window.fullscreen = false;
|
|
CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
|
|
}
|
|
}
|
|
|
|
glfwFocusWindow(platform.handle);
|
|
|
|
// Not sure why a user would want to minimize a window just after creation
|
|
// but for the sake of backward compatibility, we leave this option available here :
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow();
|
|
|
|
// We're done !
|
|
|
|
TRACELOG(LOG_INFO, "GLFW platform: %s", glfwPlatform);
|
|
TRACELOG(LOG_INFO, "PLATFORM: DESKTOP (GLFW): Initialized successfully");
|
|
|
|
return 0;
|
|
}
|
|
|
|
// Close platform
|
|
void ClosePlatform(void)
|
|
{
|
|
glfwDestroyWindow(platform.handle);
|
|
glfwTerminate();
|
|
|
|
#if defined(_WIN32) && defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP)
|
|
timeEndPeriod(1); // Restore time period
|
|
#endif
|
|
}
|
|
|
|
// GLFW3 Error Callback, runs on GLFW3 error
|
|
static void ErrorCallback(int error, const char *description)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Error: %i Description: %s", error, description);
|
|
}
|
|
|
|
// GLFW3 WindowSize Callback
|
|
// Called each time the window is resized, toggled to/from fullscreen mode,
|
|
// or when the DPI scale of the monitor is updated if `FLAG_WINDOW_HIGHDPI` is set.
|
|
// NOTE: Window resizing and DPI scaling are not enabled by default.
|
|
static void WindowSizeCallback(GLFWwindow *window, int frameBufferWidth, int frameBufferHeight)
|
|
{
|
|
CORE.Window.currentFbo.width = frameBufferWidth;
|
|
CORE.Window.currentFbo.height = frameBufferHeight;
|
|
|
|
CORE.Window.resizedLastFrame = true; // Update the indicator returned by `IsWindowResized()`
|
|
|
|
_SetupFramebuffer(frameBufferWidth, frameBufferHeight, CORE.Window.fullscreen);
|
|
|
|
SetupViewport(CORE.Window.render.width, CORE.Window.render.height);
|
|
|
|
// We have to rescale and offset the mouse coordinate system
|
|
// so that it always matches the offset and scale of the "screen" surface
|
|
|
|
_SetupMouseScaleAndOffset();
|
|
|
|
// NOTE: Postprocessing texture is not scaled to new size
|
|
}
|
|
|
|
static void _SetupMouseScaleAndOffset()
|
|
{
|
|
// Depending the current viewport and setup, we have to rescale and offset the mouse coordinate system
|
|
// returned by Raylib's mouse API functions.
|
|
|
|
// TODO : test __APPLE__ special case, @SoloByte mission
|
|
|
|
#if defined(__APPLE__)
|
|
SetMouseScale(1.0, 1.0);
|
|
#else
|
|
if (IsWindowState(FLAG_RESCALE_CONTENT) || (glfwGetPlatform() != GLFW_PLATFORM_WAYLAND))
|
|
{
|
|
float mouseScaleX = (float)CORE.Window.screen.width/(float)CORE.Window.render.width;
|
|
float mouseScaleY = (float)CORE.Window.screen.height/(float)CORE.Window.render.height;
|
|
SetMouseScale(mouseScaleX, mouseScaleY);
|
|
}
|
|
else
|
|
{
|
|
SetMouseScale(1.0, 1.0);
|
|
}
|
|
#endif
|
|
|
|
float mouseOffsetX = -0.5f*CORE.Window.renderOffset.x;
|
|
float mouseOffsetY = -0.5f*CORE.Window.renderOffset.y;
|
|
|
|
SetMouseOffset( mouseOffsetX , mouseOffsetY );
|
|
}
|
|
|
|
|
|
// Local reimplementation of SetupFramebuffer()
|
|
static void _SetupFramebuffer(int frameBufferWidth, int frameBufferHeight, bool inHardwareFullscreenMode)
|
|
{
|
|
// To avoid breaking backward compatibility and other platforms backends
|
|
// that rely on `rcore.c` implementations of `SetupFramebuffer()` and `SetupViewport()`
|
|
// this GLFW backend will use this customized `_SetupFramebuffer()` version instead.
|
|
|
|
// This version of `_SetupFramebuffer()` is meant to work with the unchanged `SetupViewport()` as of 2024-07-17.
|
|
|
|
// Let's clarify a little to avoid further confusion ...
|
|
|
|
// We use these definitions :
|
|
// --`frameBuffer` : size of the content surface of the window in which Raylib is allowed to render.
|
|
// This is the frameBuffer that is cleared with `ClearBackground()`
|
|
// - `CORE.Window.display` : size of the display resolution of the main monitor on which the window is located.
|
|
// - `CORE.Window.render` : size of the viewport in which Raylib is allowed to draw.
|
|
// The `render` VP may occupy the whole frameBuffer, or just a part of it.
|
|
// - `CORE.Window.renderOffset`: if the `render` VP is smaller than the frameBuffer, it can be centered.
|
|
// - `CORE.Window.screen` : the "screen" is a 2D space that is rescaled to fit inside the render viewport.
|
|
// - `CORE.Window.screenScale` : scale of the "screen" so it fits inside the "render" viewport.
|
|
|
|
// +---[monitor]-------------------+
|
|
// | +----[display]--------------+ |
|
|
// | | | |
|
|
// | | #[window]############ | |
|
|
// | | |+-[frameBuffer]---+| | |
|
|
// | | || +-[render]--+ || | |
|
|
// | | || | | || | |
|
|
// | | || | screen | || | |
|
|
// | | || | (rescaled)| || | |
|
|
// | | || |___________| || | |
|
|
// | | ||_________________|| | |
|
|
// | | +-------------------+ | |
|
|
// | | | |
|
|
// | +---------------------------+ |
|
|
// +-------------------------------+
|
|
|
|
|
|
// When `FLAG_RESCALE_CONTENT` is disabled (default and backward compatible mode) :
|
|
// - the size of `render` is always the same as the size of the frameBuffer
|
|
// - the size of `screen` is unscaled (scale 1.0), and is thus the same as `render`
|
|
// - the size of `screen` and `render` are expressed in pixels
|
|
// When `FLAG_WINDOW_HIGHDPI` is also enabled :
|
|
// - the size of the frameBuffer provided as arguments, is already rescaled accordingly to the DPI scale
|
|
// - the size of `render` is always the same as the size of the rescaled frameBuffer
|
|
// - the size of `screen` is also the same as `render^
|
|
|
|
// When `FLAG_RESCALE_CONTENT` is on :
|
|
// - the size of `render` is the size of `screen` rescaled to fit inside the frameBuffer
|
|
// - this means that `render` has the same aspect ratio as `screen`
|
|
// - the size of `screen` remains unchanged
|
|
// - the size of `render` is expressed in pixels
|
|
// - the size of `screen` is expressed in opengl 2D coordinate units
|
|
// - once rendered into the `render` viewport, a 'screen' space unit is equal to `CORE.Window.screenScale` pixels
|
|
// - TODO explain when FLAG_WINDOW_HIGHDPI is enabled
|
|
|
|
// Some booleans to ease code reading :
|
|
|
|
bool requestRescaledContent = (CORE.Window.flags & FLAG_RESCALE_CONTENT); // This is a new flag that breaks backward compatibility
|
|
|
|
bool weAreInBackwardCompatibleMode = !requestRescaledContent;
|
|
|
|
// If we're in backward compatible mode there is no need to rescale and offset the screen to center it into the render.
|
|
// The size of the render is always the same as the size of the frameBuffer, and the size of screen is adapted to
|
|
// the size of the render. This means that if the size of frameBuffer changes, the size of screen changes too.
|
|
|
|
if (weAreInBackwardCompatibleMode)
|
|
{
|
|
// In backward compatible mode, render always has the same size than the frameBuffer :
|
|
|
|
CORE.Window.render.width = frameBufferWidth;
|
|
CORE.Window.render.height = frameBufferHeight;
|
|
|
|
// Depending on which OS and desktop we are, the screen might
|
|
// need to be rendered accordingly to the DPI scale :
|
|
|
|
#if defined(__APPLE__)
|
|
// On MacOS the screen should not need to be rescaled according to DPI // TODO @SoloByte mission
|
|
|
|
CORE.Window.screen.width = frameBufferWidth;
|
|
CORE.Window.screen.height = frameBufferHeight;
|
|
CORE.Window.screenScale = MatrixIdentity();
|
|
#else
|
|
bool requestWindowHDPI = (CORE.Window.flags & FLAG_WINDOW_HIGHDPI);
|
|
bool weAreOnWaylandPlatform = (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND);
|
|
|
|
// On X11 and Windows, GLFW is asked to update the size of the window and its frameBuffer accordingly
|
|
// to the DPI scale of the display. The consequence is that we must rescale the screen accordingly.
|
|
// This DPI scaling is only required if the window is in windowed mode so the UI and texts are scaled
|
|
// proportionaly to the rest of the desktop environment. This also apply to `FLAG_BORDERLESS_WINDOWED_MODE`.
|
|
// In hardware fullscreen mode (aka `FLAG_FULLSCREEN_MODE`), however, DPI rescaling is not required because
|
|
// the application is running in exclusive fullscreen mode which is not meant to allow interaction with the
|
|
// rest of the desktop environment.
|
|
|
|
if (!inHardwareFullscreenMode && requestWindowHDPI && !weAreOnWaylandPlatform)
|
|
{
|
|
Vector2 windowScaleDPI = GetWindowScaleDPI();
|
|
|
|
// If the window is in windowed fullscreen mode (aka `FLAG_BORDERLESS_WINDOWED_MODE`)
|
|
// the size of the frameBuffer is set to the size of the display.
|
|
// This means that GLFW could not resize the window and its frameBuffer accordingly to the DPI.
|
|
// The consequence is that we have to recompute the size of the screen accordingly
|
|
// to the size of the frameBuffer provided by GLFW.
|
|
CORE.Window.screen.width = (unsigned int)roundf(frameBufferWidth/windowScaleDPI.x);
|
|
CORE.Window.screen.height = (unsigned int)roundf(frameBufferHeight/windowScaleDPI.y);
|
|
|
|
// And now, the screen should be scaled to fit into the render :
|
|
CORE.Window.screenScale = MatrixScale(windowScaleDPI.x, windowScaleDPI.y, 1.0);
|
|
}
|
|
else // On Wayland, the screen should not need to be rescaled // TODO test Wayland
|
|
{
|
|
CORE.Window.screen.width = frameBufferWidth;
|
|
CORE.Window.screen.height = frameBufferHeight;
|
|
CORE.Window.screenScale = MatrixIdentity();
|
|
}
|
|
#endif
|
|
|
|
// And no offset is required because the render occupy the whole frameBuffer :
|
|
|
|
CORE.Window.renderOffset.x = 0;
|
|
CORE.Window.renderOffset.y = 0;
|
|
|
|
// We can leave now :
|
|
|
|
return;
|
|
}
|
|
|
|
// We are here because `FLAG_RESCALE_CONTENT` is enabled.
|
|
// It means we want to rescale and center the `screen` into the frameBuffer.
|
|
// In this mode, `FLAG_WINDOW_HIGHDPI` has no effect, because the size of screen always remains unchanged.
|
|
// Either the size of screen is bigger than the size of frameBuffer and we need to downscale the render of screen,
|
|
// either it is smaller and we need to upscale its render.
|
|
// TODO : we may want to consider very unusual case scenario when DPI scaling is not "square" (ie non square pixels) ?
|
|
|
|
if ( requestRescaledContent )
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: FLAG_RESCALE_CONTENT is still WIP and experimental." );
|
|
}
|
|
|
|
// Upscaling or downscaling uses the same algorithm. Only the TRACELOG message changes :
|
|
|
|
bool screenIsBiggerThanDisplay = (CORE.Window.screen.width > frameBufferWidth) || (CORE.Window.screen.height > frameBufferHeight);
|
|
bool screenIsSmallerThanDisplay = !screenIsBiggerThanDisplay;
|
|
|
|
if ( screenIsBiggerThanDisplay )
|
|
{
|
|
TRACELOG(LOG_DEBUG, "DISPLAY: Downscaling required: Screen size (%ix%i) is bigger than frameBuffer size (%ix%i)", CORE.Window.screen.width, CORE.Window.screen.height, frameBufferWidth, frameBufferHeight);
|
|
}
|
|
else
|
|
if ( screenIsSmallerThanDisplay )
|
|
{
|
|
TRACELOG(LOG_DEBUG, "DISPLAY: Upscaling required: Screen size (%ix%i) is smaller than frameBuffer size (%ix%i)", CORE.Window.screen.width, CORE.Window.screen.height, frameBufferWidth, frameBufferHeight);
|
|
}
|
|
|
|
// Aspect ratio of each surface :
|
|
|
|
float frameBufferAspectRatio = (float)frameBufferWidth/(float)frameBufferHeight;
|
|
float screenAspectRatio = (float)CORE.Window.screen.width/(float)CORE.Window.screen.height;
|
|
|
|
// We need to resize render proportionaly to the aspect ratio of screen,
|
|
// so that render fits into frameBuffer with the same aspect ratio than screen.
|
|
// Once we know the size of render, we will compute the scale at which screen
|
|
// will need to be rendered to fit into render :
|
|
|
|
float screenScaleRatio = 1.0f;
|
|
|
|
if ( screenAspectRatio > frameBufferAspectRatio )
|
|
{
|
|
// Example : screen is 1600x900, and frameBuffer is 800x600
|
|
// render should be : 800x450
|
|
// (we compute directly using integers to avoid float conversions and roundings)
|
|
|
|
CORE.Window.render.width = frameBufferWidth ;
|
|
CORE.Window.render.height = CORE.Window.screen.height*frameBufferWidth/CORE.Window.screen.width;
|
|
|
|
CORE.Window.renderOffset.x = 0;
|
|
CORE.Window.renderOffset.y = (frameBufferHeight - CORE.Window.render.height);
|
|
|
|
// If the screen's aspect ratio is larger than the frameBuffer's, (like 16/9 versus 4/3)
|
|
// this means the screen will have to be rendered rescaled by the width ratio.
|
|
|
|
screenScaleRatio = (float)frameBufferWidth/(float)CORE.Window.screen.width;
|
|
}
|
|
else
|
|
{
|
|
// Example : screen is 800x600, and frameBuffer is 1600x900
|
|
// render should be : 1200x900
|
|
|
|
CORE.Window.render.width = CORE.Window.screen.width*frameBufferHeight/CORE.Window.screen.height;
|
|
CORE.Window.render.height = frameBufferHeight;
|
|
|
|
CORE.Window.renderOffset.x = (frameBufferWidth - CORE.Window.render.width);
|
|
CORE.Window.renderOffset.y = 0;
|
|
|
|
// If the screen's aspect ratio is larger than the frameBuffer's, (like 4/3 versus 16/9)
|
|
// this means the screen will have to be rendered rescaled by the height ratio.
|
|
|
|
screenScaleRatio = (float)frameBufferHeight/(float)CORE.Window.screen.height;
|
|
}
|
|
|
|
// Let's update the scale at which the drawings will occurs on the screen surface
|
|
// once rendered into the "render" viewport :
|
|
|
|
CORE.Window.screenScale = MatrixScale(screenScaleRatio, screenScaleRatio, 1.0f);
|
|
|
|
TRACELOG(LOG_DEBUG, "DISPLAY: Rescale matrix generated, content will be rendered at (%ix%i)", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
}
|
|
|
|
|
|
|
|
static bool _ActivateHardwareFullscreenMode(int monitorIndex, int desiredWidth, int desiredHeight, int desiredRefreshRate)
|
|
{
|
|
// TODO FIXME allow swtiching from one fullscreen mode to an other ?
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Fullscreen mode before initialization");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Screen scale: %f x %f", CORE.Window.screenScale.m0, CORE.Window.screenScale.m5);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
|
|
GLFWmonitor *monitor = NULL;
|
|
|
|
if (monitorIndex < 0)
|
|
{
|
|
monitor = glfwGetPrimaryMonitor();
|
|
}
|
|
else
|
|
{
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
// Use current monitor, so we correctly get the display the window is on
|
|
monitor = (monitorIndex < monitorCount)? monitors[monitorIndex] : NULL;
|
|
}
|
|
|
|
if (monitor == NULL)
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: GLFW failed to get requested monitor.");
|
|
|
|
// Here we don't know if the user is already in fullscreen mode or if the function is called
|
|
// from `InitPlatform()` which would already have `CORE.Window.fullscreen` set to `true` when
|
|
// calling this function.
|
|
// So we let the caller reset the `CORE.Window.fullscreen` and `CORE.Window.flags` as they should be
|
|
// in their scenario.
|
|
|
|
// There is nothing more to do. Just leave the window where it is.
|
|
return false;
|
|
}
|
|
|
|
// Store previous window position and size (in case we exit fullscreen)
|
|
glfwGetWindowPos(platform.handle, &CORE.Window.previousPosition.x, &CORE.Window.previousPosition.y);
|
|
|
|
// GLFW 3.4 may trigger an error if platform like Wayland don't support setting or getting the position of the window.
|
|
glfwGetError(NULL); // So we must clear this error
|
|
|
|
//!\ We must remember the size of the frameBuffer, not the size of the "screen" :
|
|
|
|
int frameBufferWidth , frameBufferHeight;
|
|
glfwGetFramebufferSize(platform.handle, &frameBufferWidth, &frameBufferHeight);
|
|
|
|
CORE.Window.previousScreen.width = frameBufferWidth;
|
|
CORE.Window.previousScreen.height = frameBufferHeight;
|
|
|
|
// Let's find a video mode that best matches our desired fullscreen mode :
|
|
|
|
const GLFWvidmode *mode = NULL ;
|
|
|
|
if (desiredWidth > 0 && desiredHeight > 0)
|
|
{
|
|
int modesCount = 0 ;
|
|
const GLFWvidmode *modes = glfwGetVideoModes(monitor, &modesCount);
|
|
|
|
for (int i = 0; i < modesCount; i++)
|
|
{
|
|
if ((desiredRefreshRate == GLFW_DONT_CARE) || (desiredRefreshRate != modes[i].refreshRate))
|
|
{
|
|
if (modes[i].width >= desiredWidth)
|
|
{
|
|
if (modes[i].height >= desiredHeight)
|
|
{
|
|
mode = &modes[i];
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// If we failed to find an appropriate video mode, we default to the current
|
|
// display mode of the monitor associated to the window :
|
|
|
|
if (mode == NULL)
|
|
{
|
|
mode = glfwGetVideoMode(monitor);
|
|
}
|
|
|
|
// Leave a tracelog of our final decision :
|
|
|
|
if ((desiredWidth != mode->width) || (desiredHeight != mode->height) || (desiredRefreshRate != mode->refreshRate))
|
|
{
|
|
TRACELOG(LOG_WARNING, "DISPLAY: Closest fullscreen videomode: %i x %i @ %i Hz", mode->width, mode->height, mode->refreshRate);
|
|
}
|
|
|
|
// Activate the fullscreen mode :
|
|
|
|
glfwSetWindowMonitor(platform.handle, monitor, 0, 0, mode->width, mode->height, mode->refreshRate);
|
|
|
|
const char *errorMessage;
|
|
int _result = glfwGetError(&errorMessage);
|
|
|
|
if (_result != GLFW_NO_ERROR)
|
|
{
|
|
TRACELOG(LOG_ERROR, "DISPLAY: GLFW failed to activate requested fullscreen mode.");
|
|
|
|
// There is nothing more to do. Just leave the window where it is.
|
|
return false;
|
|
}
|
|
|
|
// Now that the fullscreen mode is activated with success, we can update our metrics :
|
|
|
|
CORE.Window.display.width = mode->width;
|
|
CORE.Window.display.height = mode->height;
|
|
|
|
_SetupFramebuffer(mode->width, mode->height, true); // 3rd ags is `true` because we're in an hardware fullscreen mode
|
|
|
|
// Update fullscreen indicators :
|
|
|
|
CORE.Window.fullscreen = true;
|
|
CORE.Window.flags |= FLAG_FULLSCREEN_MODE;
|
|
|
|
// And we're done !
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Fullscreen mode initialized successfully");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Screen scale: %f x %f", CORE.Window.screenScale.m0, CORE.Window.screenScale.m5);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
static void _DeactivateHardwareFullscreenMode()
|
|
{
|
|
TRACELOG(LOG_INFO, "DISPLAY: Fullscreen mode before deinitialization");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Screen scale: %f x %f", CORE.Window.screenScale.m0, CORE.Window.screenScale.m5);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
|
|
// Ask GLFW to restore the window and the previous monitor resolution :
|
|
|
|
glfwSetWindowMonitor(platform.handle, NULL, CORE.Window.previousPosition.x, CORE.Window.previousPosition.y, CORE.Window.previousScreen.width, CORE.Window.previousScreen.height, GLFW_DONT_CARE);
|
|
|
|
// As we're leaving, we update the flags :
|
|
|
|
CORE.Window.fullscreen = false;
|
|
CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
|
|
|
|
// And we must restore some metrics :
|
|
|
|
int monitorIndex = GetCurrentMonitor();
|
|
|
|
CORE.Window.display.width = GetMonitorWidth(monitorIndex);
|
|
CORE.Window.display.height = GetMonitorHeight(monitorIndex);
|
|
|
|
int prevWidth = CORE.Window.previousScreen.width;
|
|
int prevHeight = CORE.Window.previousScreen.height;
|
|
|
|
if (glfwGetPlatform() == GLFW_PLATFORM_WAYLAND)
|
|
{
|
|
WindowSizeCallback(platform.handle, prevWidth, prevHeight);
|
|
}
|
|
else
|
|
{
|
|
_SetupFramebuffer(prevWidth, prevHeight, false);
|
|
}
|
|
|
|
// Then we're done !
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Fullscreen mode deinitialized successfully");
|
|
TRACELOG(LOG_INFO, " > Display size: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
TRACELOG(LOG_INFO, " > Screen size: %i x %i", CORE.Window.screen.width, CORE.Window.screen.height);
|
|
TRACELOG(LOG_INFO, " > Render size: %i x %i", CORE.Window.render.width, CORE.Window.render.height);
|
|
TRACELOG(LOG_INFO, " > Screen scale: %f x %f", CORE.Window.screenScale.m0, CORE.Window.screenScale.m5);
|
|
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
}
|
|
|
|
// GLFW3 Callback, called when the DPI of the monitor is updated
|
|
static void WindowContentScaleCallback(GLFWwindow *window, float scalex, float scaley)
|
|
{
|
|
//!\ Nothing to do here.
|
|
//!\ NOTE : The actual update of `CORE.Window.screenScale` will happen when `WindowSizeCallback()` is called.
|
|
//!\ We leave this callback active for debug and informative purpose.
|
|
|
|
TRACELOG(LOG_INFO, "SYSTEM: the DPI scaling of the monitor was udpated to %f x %f", scalex, scaley );
|
|
}
|
|
|
|
// GLFW3 WindowIconify Callback, runs when window is minimized/restored
|
|
static void WindowIconifyCallback(GLFWwindow *window, int iconified)
|
|
{
|
|
if (iconified) CORE.Window.flags |= FLAG_WINDOW_MINIMIZED; // The window was iconified
|
|
else CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED; // The window was restored
|
|
}
|
|
|
|
// GLFW3 WindowMaximize Callback, runs when window is maximized/restored
|
|
static void WindowMaximizeCallback(GLFWwindow *window, int maximized)
|
|
{
|
|
if (maximized) CORE.Window.flags |= FLAG_WINDOW_MAXIMIZED; // The window was maximized
|
|
else CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED; // The window was restored
|
|
}
|
|
|
|
// GLFW3 WindowFocus Callback, runs when window get/lose focus
|
|
static void WindowFocusCallback(GLFWwindow *window, int focused)
|
|
{
|
|
if (focused) CORE.Window.flags &= ~FLAG_WINDOW_UNFOCUSED; // The window was focused
|
|
else CORE.Window.flags |= FLAG_WINDOW_UNFOCUSED; // The window lost focus
|
|
}
|
|
|
|
// GLFW3 Window Drop Callback, runs when drop files into window
|
|
static void WindowDropCallback(GLFWwindow *window, int count, const char **paths)
|
|
{
|
|
if (count > 0)
|
|
{
|
|
// In case previous dropped filepaths have not been freed, we free them
|
|
if (CORE.Window.dropFileCount > 0)
|
|
{
|
|
for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++) RL_FREE(CORE.Window.dropFilepaths[i]);
|
|
|
|
RL_FREE(CORE.Window.dropFilepaths);
|
|
|
|
CORE.Window.dropFileCount = 0;
|
|
CORE.Window.dropFilepaths = NULL;
|
|
}
|
|
|
|
// WARNING: Paths are freed by GLFW when the callback returns, we must keep an internal copy
|
|
CORE.Window.dropFileCount = count;
|
|
CORE.Window.dropFilepaths = (char **)RL_CALLOC(CORE.Window.dropFileCount, sizeof(char *));
|
|
|
|
for (unsigned int i = 0; i < CORE.Window.dropFileCount; i++)
|
|
{
|
|
CORE.Window.dropFilepaths[i] = (char *)RL_CALLOC(MAX_FILEPATH_LENGTH, sizeof(char));
|
|
strcpy(CORE.Window.dropFilepaths[i], paths[i]);
|
|
}
|
|
}
|
|
}
|
|
|
|
// GLFW3 Keyboard Callback, runs on key pressed
|
|
static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, int mods)
|
|
{
|
|
if (key < 0) return; // Security check, macOS fn key generates -1
|
|
|
|
// WARNING: GLFW could return GLFW_REPEAT, we need to consider it as 1
|
|
// to work properly with our implementation (IsKeyDown/IsKeyUp checks)
|
|
if (action == GLFW_RELEASE) CORE.Input.Keyboard.currentKeyState[key] = 0;
|
|
else if(action == GLFW_PRESS) CORE.Input.Keyboard.currentKeyState[key] = 1;
|
|
else if(action == GLFW_REPEAT) CORE.Input.Keyboard.keyRepeatInFrame[key] = 1;
|
|
|
|
// WARNING: Check if CAPS/NUM key modifiers are enabled and force down state for those keys
|
|
if (((key == KEY_CAPS_LOCK) && ((mods & GLFW_MOD_CAPS_LOCK) > 0)) ||
|
|
((key == KEY_NUM_LOCK) && ((mods & GLFW_MOD_NUM_LOCK) > 0))) CORE.Input.Keyboard.currentKeyState[key] = 1;
|
|
|
|
// Check if there is space available in the key queue
|
|
if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS))
|
|
{
|
|
// Add character to the queue
|
|
CORE.Input.Keyboard.keyPressedQueue[CORE.Input.Keyboard.keyPressedQueueCount] = key;
|
|
CORE.Input.Keyboard.keyPressedQueueCount++;
|
|
}
|
|
|
|
// Check the exit key to set close window
|
|
if ((key == CORE.Input.Keyboard.exitKey) && (action == GLFW_PRESS)) glfwSetWindowShouldClose(platform.handle, GLFW_TRUE);
|
|
}
|
|
|
|
// GLFW3 Char Callback, get unicode codepoint value
|
|
static void CharCallback(GLFWwindow *window, unsigned int codepoint)
|
|
{
|
|
//TRACELOG(LOG_DEBUG, "Char Callback: Codepoint: %i", codepoint);
|
|
|
|
// NOTE: Registers any key down considering OS keyboard layout but
|
|
// does not detect action events, those should be managed by user...
|
|
// Ref: https://github.com/glfw/glfw/issues/668#issuecomment-166794907
|
|
// Ref: https://www.glfw.org/docs/latest/input_guide.html#input_char
|
|
|
|
// Check if there is space available in the queue
|
|
if (CORE.Input.Keyboard.charPressedQueueCount < MAX_CHAR_PRESSED_QUEUE)
|
|
{
|
|
// Add character to the queue
|
|
CORE.Input.Keyboard.charPressedQueue[CORE.Input.Keyboard.charPressedQueueCount] = codepoint;
|
|
CORE.Input.Keyboard.charPressedQueueCount++;
|
|
}
|
|
}
|
|
|
|
// GLFW3 Mouse Button Callback, runs on mouse button pressed
|
|
static void MouseButtonCallback(GLFWwindow *window, int button, int action, int mods)
|
|
{
|
|
// WARNING: GLFW could only return GLFW_PRESS (1) or GLFW_RELEASE (0) for now,
|
|
// but future releases may add more actions (i.e. GLFW_REPEAT)
|
|
CORE.Input.Mouse.currentButtonState[button] = action;
|
|
CORE.Input.Touch.currentTouchState[button] = action;
|
|
|
|
#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES)
|
|
// Process mouse events as touches to be able to use mouse-gestures
|
|
GestureEvent gestureEvent = { 0 };
|
|
|
|
// Register touch actions
|
|
if ((CORE.Input.Mouse.currentButtonState[button] == 1) && (CORE.Input.Mouse.previousButtonState[button] == 0)) gestureEvent.touchAction = TOUCH_ACTION_DOWN;
|
|
else if ((CORE.Input.Mouse.currentButtonState[button] == 0) && (CORE.Input.Mouse.previousButtonState[button] == 1)) gestureEvent.touchAction = TOUCH_ACTION_UP;
|
|
|
|
// NOTE: TOUCH_ACTION_MOVE event is registered in MouseCursorPosCallback()
|
|
|
|
// Assign a pointer ID
|
|
gestureEvent.pointId[0] = 0;
|
|
|
|
// Register touch points count
|
|
gestureEvent.pointCount = 1;
|
|
|
|
// Register touch points position, only one point registered
|
|
gestureEvent.position[0] = GetMousePosition();
|
|
|
|
// Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
|
|
gestureEvent.position[0].x /= (float)GetScreenWidth();
|
|
gestureEvent.position[0].y /= (float)GetScreenHeight();
|
|
|
|
// Gesture data is sent to gestures-system for processing
|
|
ProcessGestureEvent(gestureEvent);
|
|
#endif
|
|
}
|
|
|
|
// GLFW3 Cursor Position Callback, runs on mouse move
|
|
static void MouseCursorPosCallback(GLFWwindow *window, double x, double y)
|
|
{
|
|
CORE.Input.Mouse.currentPosition.x = (float)x;
|
|
CORE.Input.Mouse.currentPosition.y = (float)y;
|
|
CORE.Input.Touch.position[0] = CORE.Input.Mouse.currentPosition;
|
|
|
|
#if defined(SUPPORT_GESTURES_SYSTEM) && defined(SUPPORT_MOUSE_GESTURES)
|
|
// Process mouse events as touches to be able to use mouse-gestures
|
|
GestureEvent gestureEvent = { 0 };
|
|
|
|
gestureEvent.touchAction = TOUCH_ACTION_MOVE;
|
|
|
|
// Assign a pointer ID
|
|
gestureEvent.pointId[0] = 0;
|
|
|
|
// Register touch points count
|
|
gestureEvent.pointCount = 1;
|
|
|
|
// Register touch points position, only one point registered
|
|
gestureEvent.position[0] = CORE.Input.Touch.position[0];
|
|
|
|
// Normalize gestureEvent.position[0] for CORE.Window.screen.width and CORE.Window.screen.height
|
|
gestureEvent.position[0].x /= (float)GetScreenWidth();
|
|
gestureEvent.position[0].y /= (float)GetScreenHeight();
|
|
|
|
// Gesture data is sent to gestures-system for processing
|
|
ProcessGestureEvent(gestureEvent);
|
|
#endif
|
|
}
|
|
|
|
// GLFW3 Scrolling Callback, runs on mouse wheel
|
|
static void MouseScrollCallback(GLFWwindow *window, double xoffset, double yoffset)
|
|
{
|
|
CORE.Input.Mouse.currentWheelMove = (Vector2){ (float)xoffset, (float)yoffset };
|
|
}
|
|
|
|
// GLFW3 CursorEnter Callback, when cursor enters the window
|
|
static void CursorEnterCallback(GLFWwindow *window, int enter)
|
|
{
|
|
if (enter) CORE.Input.Mouse.cursorOnScreen = true;
|
|
else CORE.Input.Mouse.cursorOnScreen = false;
|
|
}
|
|
|
|
// GLFW3 Joystick Connected/Disconnected Callback
|
|
static void JoystickCallback(int jid, int event)
|
|
{
|
|
if (event == GLFW_CONNECTED)
|
|
{
|
|
strcpy(CORE.Input.Gamepad.name[jid], glfwGetJoystickName(jid));
|
|
}
|
|
else if (event == GLFW_DISCONNECTED)
|
|
{
|
|
memset(CORE.Input.Gamepad.name[jid], 0, 64);
|
|
}
|
|
}
|
|
|
|
// EOF
|