1711 lines
69 KiB
1711 lines
69 KiB
#include <stdlib.h>
|
|
|
|
#include "rcore.h"
|
|
|
|
#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
|
|
//#define GLFW_EXPOSE_NATIVE_MIR
|
|
#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
|
|
|
|
static bool InitGraphicsDevice(int width, int height); // Initialize graphics device
|
|
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 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
|
|
// 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 key); // GLFW3 Char Key Callback, runs on key pressed (get char 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 Srolling Callback, runs on mouse wheel
|
|
static void CursorEnterCallback(GLFWwindow *window, int enter); // GLFW3 Cursor Enter Callback, cursor enters client area
|
|
|
|
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 WindowMaximizeCallback(GLFWwindow* window, int maximized); // GLFW3 Window Maximize Callback, runs when window is maximized
|
|
static void WindowIconifyCallback(GLFWwindow *window, int iconified); // GLFW3 WindowIconify Callback, runs when window is minimized/restored
|
|
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
|
|
// 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 key); // GLFW3 Char Key Callback, runs on key pressed (get char 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 Srolling Callback, runs on mouse wheel
|
|
static void CursorEnterCallback(GLFWwindow *window, int enter); // GLFW3 Cursor Enter Callback, cursor enters client area
|
|
|
|
// Initialize window and OpenGL context
|
|
// NOTE: data parameter could be used to pass any kind of required data to the initialization
|
|
void InitWindow(int width, int height, const char *title)
|
|
{
|
|
TRACELOG(LOG_INFO, "Initializing raylib %s", RAYLIB_VERSION);
|
|
|
|
TRACELOG(LOG_INFO, "Supported raylib modules:");
|
|
TRACELOG(LOG_INFO, " > rcore:..... loaded (mandatory)");
|
|
TRACELOG(LOG_INFO, " > rlgl:...... loaded (mandatory)");
|
|
#if defined(SUPPORT_MODULE_RSHAPES)
|
|
TRACELOG(LOG_INFO, " > rshapes:... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rshapes:... not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RTEXTURES)
|
|
TRACELOG(LOG_INFO, " > rtextures:. loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rtextures:. not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RTEXT)
|
|
TRACELOG(LOG_INFO, " > rtext:..... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rtext:..... not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RMODELS)
|
|
TRACELOG(LOG_INFO, " > rmodels:... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > rmodels:... not loaded (optional)");
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RAUDIO)
|
|
TRACELOG(LOG_INFO, " > raudio:.... loaded (optional)");
|
|
#else
|
|
TRACELOG(LOG_INFO, " > raudio:.... not loaded (optional)");
|
|
#endif
|
|
|
|
if ((title != NULL) && (title[0] != 0)) CORE.Window.title = title;
|
|
|
|
// Initialize global input state
|
|
memset(&CORE.Input, 0, sizeof(CORE.Input));
|
|
CORE.Input.Keyboard.exitKey = KEY_ESCAPE;
|
|
CORE.Input.Mouse.scale = (Vector2){ 1.0f, 1.0f };
|
|
CORE.Input.Mouse.cursor = MOUSE_CURSOR_ARROW;
|
|
CORE.Input.Gamepad.lastButtonPressed = 0; // GAMEPAD_BUTTON_UNKNOWN
|
|
#if defined(SUPPORT_EVENTS_WAITING)
|
|
CORE.Window.eventWaiting = true;
|
|
#endif
|
|
// Initialize graphics device (display device and OpenGL context)
|
|
// NOTE: returns true if window and graphic device has been initialized successfully
|
|
CORE.Window.ready = InitGraphicsDevice(width, height);
|
|
|
|
// If graphic device is no properly initialized, we end program
|
|
if (!CORE.Window.ready)
|
|
{
|
|
TRACELOG(LOG_FATAL, "Failed to initialize Graphic Device");
|
|
return;
|
|
}
|
|
else SetWindowPosition(GetMonitorWidth(GetCurrentMonitor())/2 - CORE.Window.screen.width/2, GetMonitorHeight(GetCurrentMonitor())/2 - CORE.Window.screen.height/2);
|
|
|
|
// Initialize hi-res timer
|
|
InitTimer();
|
|
|
|
// Initialize random seed
|
|
srand((unsigned int)time(NULL));
|
|
|
|
// Initialize base path for storage
|
|
CORE.Storage.basePath = GetWorkingDirectory();
|
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT)
|
|
// Load default font
|
|
// WARNING: External function: Module required: rtext
|
|
LoadFontDefault();
|
|
#if defined(SUPPORT_MODULE_RSHAPES)
|
|
// Set font white rectangle for shapes drawing, so shapes and text can be batched together
|
|
// WARNING: rshapes module is required, if not available, default internal white rectangle is used
|
|
Rectangle rec = GetFontDefault().recs[95];
|
|
if (CORE.Window.flags & FLAG_MSAA_4X_HINT)
|
|
{
|
|
// NOTE: We try to maxime rec padding to avoid pixel bleeding on MSAA filtering
|
|
SetShapesTexture(GetFontDefault().texture, (Rectangle){ rec.x + 2, rec.y + 2, 1, 1 });
|
|
}
|
|
else
|
|
{
|
|
// NOTE: We set up a 1px padding on char rectangle to avoid pixel bleeding
|
|
SetShapesTexture(GetFontDefault().texture, (Rectangle){ rec.x + 1, rec.y + 1, rec.width - 2, rec.height - 2 });
|
|
}
|
|
#endif
|
|
#else
|
|
#if defined(SUPPORT_MODULE_RSHAPES)
|
|
// Set default texture and rectangle to be used for shapes drawing
|
|
// NOTE: rlgl default texture is a 1x1 pixel UNCOMPRESSED_R8G8B8A8
|
|
Texture2D texture = { rlGetTextureIdDefault(), 1, 1, 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 };
|
|
SetShapesTexture(texture, (Rectangle){ 0.0f, 0.0f, 1.0f, 1.0f }); // WARNING: Module required: rshapes
|
|
#endif
|
|
#endif
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT)
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
// Set default font texture filter for HighDPI (blurry)
|
|
// RL_TEXTURE_FILTER_LINEAR - tex filter: BILINEAR, no mipmaps
|
|
rlTextureParameters(GetFontDefault().texture.id, RL_TEXTURE_MIN_FILTER, RL_TEXTURE_FILTER_LINEAR);
|
|
rlTextureParameters(GetFontDefault().texture.id, RL_TEXTURE_MAG_FILTER, RL_TEXTURE_FILTER_LINEAR);
|
|
}
|
|
#endif
|
|
|
|
#if defined(SUPPORT_EVENTS_AUTOMATION)
|
|
events = (AutomationEvent *)RL_CALLOC(MAX_CODE_AUTOMATION_EVENTS, sizeof(AutomationEvent));
|
|
CORE.Time.frameCounter = 0;
|
|
#endif
|
|
}
|
|
|
|
|
|
// Initialize display device and framebuffer
|
|
// NOTE: width and height represent the screen (framebuffer) desired size, not actual display size
|
|
// If width or height are 0, default display size will be used for framebuffer size
|
|
// NOTE: returns false in case graphic device could not be created
|
|
static bool InitGraphicsDevice(int width, int height)
|
|
{
|
|
CORE.Window.screen.width = width; // User desired width
|
|
CORE.Window.screen.height = height; // User desired height
|
|
CORE.Window.screenScale = MatrixIdentity(); // No draw scaling required by default
|
|
|
|
// Set the window minimum and maximum default values to 0
|
|
CORE.Window.windowMin.width = 0;
|
|
CORE.Window.windowMin.height = 0;
|
|
CORE.Window.windowMax.width = 0;
|
|
CORE.Window.windowMax.height = 0;
|
|
|
|
// NOTE: Framebuffer (render area - CORE.Window.render.width, CORE.Window.render.height) could include black bars...
|
|
// ...in top-down or left-right to match display aspect ratio (no weird scaling)
|
|
|
|
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
|
|
|
|
if (!glfwInit())
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to initialize GLFW");
|
|
return false;
|
|
}
|
|
|
|
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)
|
|
{
|
|
// Resize window content area based on the monitor content scale.
|
|
// NOTE: This hint only has an effect on platforms where screen coordinates and pixels always map 1:1 such as Windows and X11.
|
|
// On platforms like macOS the resolution of the framebuffer is changed independently of the window size.
|
|
glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); // Scale content area based on the monitor content scale where window is placed on
|
|
#if defined(__APPLE__)
|
|
glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
|
|
#endif
|
|
}
|
|
else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
|
|
|
|
// 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
|
|
if (MAX_GAMEPADS > 0) glfwSetJoystickCallback(NULL);
|
|
|
|
// Find monitor resolution
|
|
GLFWmonitor *monitor = glfwGetPrimaryMonitor();
|
|
if (!monitor)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to get primary monitor");
|
|
return false;
|
|
}
|
|
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
|
|
|
|
CORE.Window.display.width = mode->width;
|
|
CORE.Window.display.height = mode->height;
|
|
|
|
// Set screen width/height to the display width/height if they are 0
|
|
if (CORE.Window.screen.width == 0) CORE.Window.screen.width = CORE.Window.display.width;
|
|
if (CORE.Window.screen.height == 0) CORE.Window.screen.height = CORE.Window.display.height;
|
|
|
|
if (CORE.Window.fullscreen)
|
|
{
|
|
// remember center for switchinging from fullscreen to window
|
|
if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
|
|
{
|
|
// If screen width/height equal to the display, we can't calculate the window pos for toggling full-screened/windowed.
|
|
// Toggling full-screened/windowed with pos(0, 0) can cause problems in some platforms, such as X11.
|
|
CORE.Window.position.x = CORE.Window.display.width/4;
|
|
CORE.Window.position.y = CORE.Window.display.height/4;
|
|
}
|
|
else
|
|
{
|
|
CORE.Window.position.x = CORE.Window.display.width/2 - CORE.Window.screen.width/2;
|
|
CORE.Window.position.y = CORE.Window.display.height/2 - CORE.Window.screen.height/2;
|
|
}
|
|
|
|
if (CORE.Window.position.x < 0) CORE.Window.position.x = 0;
|
|
if (CORE.Window.position.y < 0) CORE.Window.position.y = 0;
|
|
|
|
// Obtain recommended CORE.Window.display.width/CORE.Window.display.height from a valid videomode for the monitor
|
|
int count = 0;
|
|
const GLFWvidmode *modes = glfwGetVideoModes(glfwGetPrimaryMonitor(), &count);
|
|
|
|
// Get closest video mode to desired CORE.Window.screen.width/CORE.Window.screen.height
|
|
for (int i = 0; i < count; i++)
|
|
{
|
|
if ((unsigned int)modes[i].width >= CORE.Window.screen.width)
|
|
{
|
|
if ((unsigned int)modes[i].height >= CORE.Window.screen.height)
|
|
{
|
|
CORE.Window.display.width = modes[i].width;
|
|
CORE.Window.display.height = modes[i].height;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
TRACELOG(LOG_WARNING, "SYSTEM: Closest fullscreen videomode: %i x %i", CORE.Window.display.width, CORE.Window.display.height);
|
|
|
|
// NOTE: ISSUE: Closest videomode could not match monitor aspect-ratio, for example,
|
|
// for a desired screen size of 800x450 (16:9), closest supported videomode is 800x600 (4:3),
|
|
// framebuffer is rendered correctly but once displayed on a 16:9 monitor, it gets stretched
|
|
// by the sides to fit all monitor space...
|
|
|
|
// Try to setup the most appropriate fullscreen framebuffer for the requested screenWidth/screenHeight
|
|
// It considers device display resolution mode and setups a framebuffer with black bars if required (render size/offset)
|
|
// Modified global variables: CORE.Window.screen.width/CORE.Window.screen.height - CORE.Window.render.width/CORE.Window.render.height - CORE.Window.renderOffset.x/CORE.Window.renderOffset.y - CORE.Window.screenScale
|
|
// TODO: It is a quite cumbersome solution to display size vs requested size, it should be reviewed or removed...
|
|
// HighDPI monitors are properly considered in a following similar function: SetupViewport()
|
|
SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
|
|
|
|
CORE.Window.handle = glfwCreateWindow(CORE.Window.display.width, CORE.Window.display.height, (CORE.Window.title != 0)? CORE.Window.title : " ", glfwGetPrimaryMonitor(), NULL);
|
|
|
|
// NOTE: Full-screen change, not working properly...
|
|
//glfwSetWindowMonitor(CORE.Window.handle, glfwGetPrimaryMonitor(), 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
|
|
}
|
|
else
|
|
{
|
|
// If we are windowed fullscreen, ensures that window does not minimize when focus is lost
|
|
if ((CORE.Window.screen.height == CORE.Window.display.height) && (CORE.Window.screen.width == CORE.Window.display.width))
|
|
{
|
|
glfwWindowHint(GLFW_AUTO_ICONIFY, 0);
|
|
}
|
|
|
|
// No-fullscreen window creation
|
|
CORE.Window.handle = glfwCreateWindow(CORE.Window.screen.width, CORE.Window.screen.height, (CORE.Window.title != 0)? CORE.Window.title : " ", NULL, NULL);
|
|
|
|
if (CORE.Window.handle)
|
|
{
|
|
CORE.Window.render.width = CORE.Window.screen.width;
|
|
CORE.Window.render.height = CORE.Window.screen.height;
|
|
}
|
|
}
|
|
|
|
if (!CORE.Window.handle)
|
|
{
|
|
glfwTerminate();
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to initialize Window");
|
|
return false;
|
|
}
|
|
|
|
// Set window callback events
|
|
glfwSetWindowSizeCallback(CORE.Window.handle, WindowSizeCallback); // NOTE: Resizing not allowed by default!
|
|
glfwSetWindowMaximizeCallback(CORE.Window.handle, WindowMaximizeCallback);
|
|
glfwSetWindowIconifyCallback(CORE.Window.handle, WindowIconifyCallback);
|
|
glfwSetWindowFocusCallback(CORE.Window.handle, WindowFocusCallback);
|
|
glfwSetDropCallback(CORE.Window.handle, WindowDropCallback);
|
|
|
|
// Set input callback events
|
|
glfwSetKeyCallback(CORE.Window.handle, KeyCallback);
|
|
glfwSetCharCallback(CORE.Window.handle, CharCallback);
|
|
glfwSetMouseButtonCallback(CORE.Window.handle, MouseButtonCallback);
|
|
glfwSetCursorPosCallback(CORE.Window.handle, MouseCursorPosCallback); // Track mouse position changes
|
|
glfwSetScrollCallback(CORE.Window.handle, MouseScrollCallback);
|
|
glfwSetCursorEnterCallback(CORE.Window.handle, CursorEnterCallback);
|
|
|
|
glfwMakeContextCurrent(CORE.Window.handle);
|
|
|
|
glfwSetInputMode(CORE.Window.handle, GLFW_LOCK_KEY_MODS, GLFW_TRUE); // Enable lock keys modifiers (CAPS, NUM)
|
|
|
|
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 (CORE.Window.flags & FLAG_VSYNC_HINT)
|
|
{
|
|
// WARNING: It seems to hit a critical render path in Intel HD Graphics
|
|
glfwSwapInterval(1);
|
|
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable VSYNC");
|
|
}
|
|
|
|
int fbWidth = CORE.Window.screen.width;
|
|
int fbHeight = CORE.Window.screen.height;
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_HIGHDPI) > 0)
|
|
{
|
|
// NOTE: On APPLE platforms system should manage window/input scaling and also framebuffer scaling.
|
|
// Framebuffer scaling should be activated with: glfwWindowHint(GLFW_COCOA_RETINA_FRAMEBUFFER, GLFW_TRUE);
|
|
#if !defined(__APPLE__)
|
|
glfwGetFramebufferSize(CORE.Window.handle, &fbWidth, &fbHeight);
|
|
|
|
// Screen scaling matrix is required in case desired screen area is different from display area
|
|
CORE.Window.screenScale = MatrixScale((float)fbWidth/CORE.Window.screen.width, (float)fbHeight/CORE.Window.screen.height, 1.0f);
|
|
|
|
// Mouse input scaling for the new screen size
|
|
SetMouseScale((float)CORE.Window.screen.width/fbWidth, (float)CORE.Window.screen.height/fbHeight);
|
|
#endif
|
|
}
|
|
|
|
CORE.Window.render.width = fbWidth;
|
|
CORE.Window.render.height = fbHeight;
|
|
CORE.Window.currentFbo.width = fbWidth;
|
|
CORE.Window.currentFbo.height = fbHeight;
|
|
|
|
TRACELOG(LOG_INFO, "DISPLAY: Device 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, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
|
|
|
|
// Load OpenGL extensions
|
|
// NOTE: GL procedures address loader is required to load extensions
|
|
|
|
rlLoadExtensions(glfwGetProcAddress);
|
|
|
|
// Initialize OpenGL context (states and resources)
|
|
// NOTE: CORE.Window.currentFbo.width and CORE.Window.currentFbo.height not used, just stored as globals in rlgl
|
|
rlglInit(CORE.Window.currentFbo.width, CORE.Window.currentFbo.height);
|
|
|
|
// Setup default viewport
|
|
// NOTE: It updated CORE.Window.render.width and CORE.Window.render.height
|
|
SetupViewport(CORE.Window.currentFbo.width, CORE.Window.currentFbo.height);
|
|
|
|
if ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow();
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
// Close window and unload OpenGL context
|
|
void CloseWindow(void)
|
|
{
|
|
#if defined(SUPPORT_GIF_RECORDING)
|
|
if (gifRecording)
|
|
{
|
|
MsfGifResult result = msf_gif_end(&gifState);
|
|
msf_gif_free(result);
|
|
gifRecording = false;
|
|
}
|
|
#endif
|
|
|
|
#if defined(SUPPORT_MODULE_RTEXT) && defined(SUPPORT_DEFAULT_FONT)
|
|
UnloadFontDefault(); // WARNING: Module required: rtext
|
|
#endif
|
|
|
|
rlglClose(); // De-init rlgl
|
|
|
|
glfwDestroyWindow(CORE.Window.handle);
|
|
glfwTerminate();
|
|
|
|
#if defined(_WIN32) && defined(SUPPORT_WINMM_HIGHRES_TIMER) && !defined(SUPPORT_BUSY_WAIT_LOOP)
|
|
timeEndPeriod(1); // Restore time period
|
|
#endif
|
|
|
|
#if defined(SUPPORT_EVENTS_AUTOMATION)
|
|
RL_FREE(events);
|
|
#endif
|
|
|
|
CORE.Window.ready = false;
|
|
TRACELOG(LOG_INFO, "Window closed successfully");
|
|
}
|
|
|
|
|
|
|
|
// Check if KEY_ESCAPE pressed or Close icon pressed
|
|
bool WindowShouldClose(void)
|
|
{
|
|
if (CORE.Window.ready)
|
|
{
|
|
// While window minimized, stop loop execution
|
|
while (IsWindowState(FLAG_WINDOW_MINIMIZED) && !IsWindowState(FLAG_WINDOW_ALWAYS_RUN)) glfwWaitEvents();
|
|
|
|
CORE.Window.shouldClose = glfwWindowShouldClose(CORE.Window.handle);
|
|
|
|
// Reset close status for next frame
|
|
glfwSetWindowShouldClose(CORE.Window.handle, GLFW_FALSE);
|
|
|
|
return CORE.Window.shouldClose;
|
|
}
|
|
else return true;
|
|
}
|
|
|
|
// Check if window is currently hidden
|
|
bool IsWindowHidden(void)
|
|
{
|
|
return ((CORE.Window.flags & FLAG_WINDOW_HIDDEN) > 0);
|
|
}
|
|
|
|
// Check if window has been minimized
|
|
bool IsWindowMinimized(void)
|
|
{
|
|
return ((CORE.Window.flags & FLAG_WINDOW_MINIMIZED) > 0);
|
|
}
|
|
|
|
|
|
// Check if window has been maximized (only PLATFORM_DESKTOP)
|
|
bool IsWindowMaximized(void)
|
|
{
|
|
return ((CORE.Window.flags & FLAG_WINDOW_MAXIMIZED) > 0);
|
|
}
|
|
|
|
// Check if window has the focus
|
|
bool IsWindowFocused(void)
|
|
{
|
|
return ((CORE.Window.flags & FLAG_WINDOW_UNFOCUSED) == 0);
|
|
}
|
|
|
|
// Check if window has been resizedLastFrame
|
|
bool IsWindowResized(void)
|
|
{
|
|
return CORE.Window.resizedLastFrame;
|
|
}
|
|
|
|
// Toggle fullscreen mode (only PLATFORM_DESKTOP)
|
|
void ToggleFullscreen(void)
|
|
{
|
|
if (!CORE.Window.fullscreen)
|
|
{
|
|
// Store previous window position (in case we exit fullscreen)
|
|
glfwGetWindowPos(CORE.Window.handle, &CORE.Window.position.x, &CORE.Window.position.y);
|
|
|
|
int monitorCount = 0;
|
|
int monitorIndex = GetCurrentMonitor();
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
// Use current monitor, so we correctly get the display the window is on
|
|
GLFWmonitor *monitor = (monitorIndex < monitorCount)? monitors[monitorIndex] : NULL;
|
|
|
|
if (monitor == NULL)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Failed to get monitor");
|
|
|
|
CORE.Window.fullscreen = false;
|
|
CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
|
|
|
|
glfwSetWindowMonitor(CORE.Window.handle, NULL, 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
|
|
}
|
|
else
|
|
{
|
|
CORE.Window.fullscreen = true;
|
|
CORE.Window.flags |= FLAG_FULLSCREEN_MODE;
|
|
|
|
glfwSetWindowMonitor(CORE.Window.handle, monitor, 0, 0, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
|
|
}
|
|
|
|
}
|
|
else
|
|
{
|
|
CORE.Window.fullscreen = false;
|
|
CORE.Window.flags &= ~FLAG_FULLSCREEN_MODE;
|
|
|
|
glfwSetWindowMonitor(CORE.Window.handle, NULL, CORE.Window.position.x, CORE.Window.position.y, CORE.Window.screen.width, CORE.Window.screen.height, GLFW_DONT_CARE);
|
|
}
|
|
|
|
// 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);
|
|
}
|
|
|
|
|
|
// Set window state: maximized, if resizable (only PLATFORM_DESKTOP)
|
|
void MaximizeWindow(void)
|
|
{
|
|
if (glfwGetWindowAttrib(CORE.Window.handle, GLFW_RESIZABLE) == GLFW_TRUE)
|
|
{
|
|
glfwMaximizeWindow(CORE.Window.handle);
|
|
CORE.Window.flags |= FLAG_WINDOW_MAXIMIZED;
|
|
}
|
|
}
|
|
|
|
// Set window state: minimized (only PLATFORM_DESKTOP)
|
|
void MinimizeWindow(void)
|
|
{
|
|
// NOTE: Following function launches callback that sets appropriate flag!
|
|
glfwIconifyWindow(CORE.Window.handle);
|
|
}
|
|
|
|
// Set window state: not minimized/maximized (only PLATFORM_DESKTOP)
|
|
void RestoreWindow(void)
|
|
{
|
|
if (glfwGetWindowAttrib(CORE.Window.handle, GLFW_RESIZABLE) == GLFW_TRUE)
|
|
{
|
|
// Restores the specified window if it was previously iconified (minimized) or maximized
|
|
glfwRestoreWindow(CORE.Window.handle);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_MINIMIZED;
|
|
CORE.Window.flags &= ~FLAG_WINDOW_MAXIMIZED;
|
|
}
|
|
}
|
|
|
|
|
|
// Toggle borderless windowed mode (only PLATFORM_DESKTOP)
|
|
void ToggleBorderlessWindowed(void)
|
|
{
|
|
// Leave fullscreen before attempting to set borderless windowed mode and get screen position from it
|
|
bool wasOnFullscreen = false;
|
|
if (CORE.Window.fullscreen)
|
|
{
|
|
CORE.Window.previousPosition = CORE.Window.position;
|
|
ToggleFullscreen();
|
|
wasOnFullscreen = true;
|
|
}
|
|
|
|
const int monitor = GetCurrentMonitor();
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
if (mode)
|
|
{
|
|
if (!IsWindowState(FLAG_BORDERLESS_WINDOWED_MODE))
|
|
{
|
|
// Store screen position and size
|
|
// NOTE: If it was on fullscreen, screen position was already stored, so skip setting it here
|
|
if (!wasOnFullscreen) glfwGetWindowPos(CORE.Window.handle, &CORE.Window.previousPosition.x, &CORE.Window.previousPosition.y);
|
|
CORE.Window.previousScreen = CORE.Window.screen;
|
|
|
|
// Set undecorated and topmost modes and flags
|
|
glfwSetWindowAttrib(CORE.Window.handle, GLFW_DECORATED, GLFW_FALSE);
|
|
CORE.Window.flags |= FLAG_WINDOW_UNDECORATED;
|
|
glfwSetWindowAttrib(CORE.Window.handle, GLFW_FLOATING, GLFW_TRUE);
|
|
CORE.Window.flags |= FLAG_WINDOW_TOPMOST;
|
|
|
|
// Get monitor position and size
|
|
int monitorPosX = 0;
|
|
int monitorPosY = 0;
|
|
glfwGetMonitorPos(monitors[monitor], &monitorPosX, &monitorPosY);
|
|
const int monitorWidth = mode->width;
|
|
const int monitorHeight = mode->height;
|
|
glfwSetWindowSize(CORE.Window.handle, monitorWidth, monitorHeight);
|
|
|
|
// Set screen position and size
|
|
glfwSetWindowPos(CORE.Window.handle, monitorPosX, monitorPosY);
|
|
glfwSetWindowSize(CORE.Window.handle, monitorWidth, monitorHeight);
|
|
|
|
// Refocus window
|
|
glfwFocusWindow(CORE.Window.handle);
|
|
|
|
CORE.Window.flags |= FLAG_BORDERLESS_WINDOWED_MODE;
|
|
}
|
|
else
|
|
{
|
|
// Remove topmost and undecorated modes and flags
|
|
glfwSetWindowAttrib(CORE.Window.handle, GLFW_FLOATING, GLFW_FALSE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_TOPMOST;
|
|
glfwSetWindowAttrib(CORE.Window.handle, GLFW_DECORATED, GLFW_TRUE);
|
|
CORE.Window.flags &= ~FLAG_WINDOW_UNDECORATED;
|
|
|
|
// Return previous screen size and position
|
|
// NOTE: The order matters here, it must set size first, then set position, otherwise the screen will be positioned incorrectly
|
|
glfwSetWindowSize(CORE.Window.handle, CORE.Window.previousScreen.width, CORE.Window.previousScreen.height);
|
|
glfwSetWindowPos(CORE.Window.handle, CORE.Window.previousPosition.x, CORE.Window.previousPosition.y);
|
|
|
|
// Refocus window
|
|
glfwFocusWindow(CORE.Window.handle);
|
|
|
|
CORE.Window.flags &= ~FLAG_BORDERLESS_WINDOWED_MODE;
|
|
}
|
|
}
|
|
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 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(CORE.Window.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(CORE.Window.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(CORE.Window.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(CORE.Window.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(CORE.Window.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(CORE.Window.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");
|
|
}
|
|
}
|
|
|
|
// 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(CORE.Window.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(CORE.Window.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(CORE.Window.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(CORE.Window.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(CORE.Window.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(CORE.Window.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");
|
|
}
|
|
}
|
|
|
|
// Set icon for window (only PLATFORM_DESKTOP)
|
|
// 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(CORE.Window.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(CORE.Window.handle, 1, icon);
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Window icon image must be in R8G8B8A8 pixel format");
|
|
}
|
|
}
|
|
|
|
// Set icon for window (multiple images, only PLATFORM_DESKTOP)
|
|
// 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(CORE.Window.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(CORE.Window.handle, valid, icons);
|
|
|
|
RL_FREE(icons);
|
|
}
|
|
}
|
|
|
|
// Set title for window (only PLATFORM_DESKTOP and PLATFORM_WEB)
|
|
void SetWindowTitle(const char *title)
|
|
{
|
|
CORE.Window.title = title;
|
|
glfwSetWindowTitle(CORE.Window.handle, title);
|
|
}
|
|
|
|
// Set window position on screen (windowed mode)
|
|
void SetWindowPosition(int x, int y)
|
|
{
|
|
glfwSetWindowPos(CORE.Window.handle, x, y);
|
|
}
|
|
|
|
// Set monitor for the current window
|
|
void SetWindowMonitor(int monitor)
|
|
{
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
if (CORE.Window.fullscreen)
|
|
{
|
|
TRACELOG(LOG_INFO, "GLFW: Selected fullscreen monitor: [%i] %s", monitor, glfwGetMonitorName(monitors[monitor]));
|
|
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
glfwSetWindowMonitor(CORE.Window.handle, monitors[monitor], 0, 0, mode->width, mode->height, mode->refreshRate);
|
|
}
|
|
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(CORE.Window.handle, monitorWorkareaX, monitorWorkareaY);
|
|
else
|
|
{
|
|
const int x = monitorWorkareaX + (monitorWorkareaWidth/2) - (screenWidth/2);
|
|
const int y = monitorWorkareaY + (monitorWorkareaHeight/2) - (screenHeight/2);
|
|
glfwSetWindowPos(CORE.Window.handle, x, y);
|
|
}
|
|
}
|
|
}
|
|
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.windowMin.width = width;
|
|
CORE.Window.windowMin.height = height;
|
|
int minWidth = (CORE.Window.windowMin.width == 0) ? GLFW_DONT_CARE : CORE.Window.windowMin.width;
|
|
int minHeight = (CORE.Window.windowMin.height == 0) ? GLFW_DONT_CARE : CORE.Window.windowMin.height;
|
|
int maxWidth = (CORE.Window.windowMax.width == 0) ? GLFW_DONT_CARE : CORE.Window.windowMax.width;
|
|
int maxHeight = (CORE.Window.windowMax.height == 0) ? GLFW_DONT_CARE : CORE.Window.windowMax.height;
|
|
glfwSetWindowSizeLimits(CORE.Window.handle, minWidth, minHeight, maxWidth, maxHeight);
|
|
}
|
|
|
|
// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE)
|
|
void SetWindowMaxSize(int width, int height)
|
|
{
|
|
CORE.Window.windowMax.width = width;
|
|
CORE.Window.windowMax.height = height;
|
|
int minWidth = (CORE.Window.windowMin.width == 0) ? GLFW_DONT_CARE : CORE.Window.windowMin.width;
|
|
int minHeight = (CORE.Window.windowMin.height == 0) ? GLFW_DONT_CARE : CORE.Window.windowMin.height;
|
|
int maxWidth = (CORE.Window.windowMax.width == 0) ? GLFW_DONT_CARE : CORE.Window.windowMax.width;
|
|
int maxHeight = (CORE.Window.windowMax.height == 0) ? GLFW_DONT_CARE : CORE.Window.windowMax.height;
|
|
glfwSetWindowSizeLimits(CORE.Window.handle, minWidth, minHeight, maxWidth, maxHeight);
|
|
}
|
|
|
|
// Set window dimensions
|
|
void SetWindowSize(int width, int height)
|
|
{
|
|
glfwSetWindowSize(CORE.Window.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(CORE.Window.handle, opacity);
|
|
}
|
|
|
|
// Set window focused
|
|
void SetWindowFocused(void)
|
|
{
|
|
glfwFocusWindow(CORE.Window.handle);
|
|
}
|
|
|
|
// 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 Error Callback, runs on GLFW3 error
|
|
static void ErrorCallback(int error, const char *description)
|
|
{
|
|
TRACELOG(LOG_WARNING, "GLFW: Error: %i Description: %s", error, description);
|
|
}
|
|
|
|
// Get native window handle
|
|
void *GetWindowHandle(void)
|
|
{
|
|
#if defined(PLATFORM_DESKTOP) && defined(_WIN32)
|
|
// NOTE: Returned handle is: void *HWND (windows.h)
|
|
return glfwGetWin32Window(CORE.Window.handle);
|
|
#endif
|
|
#if defined(PLATFORM_DESKTOP) && defined(__linux__)
|
|
// NOTE: Returned handle is: unsigned long Window (X.h)
|
|
// typedef unsigned long XID;
|
|
// typedef XID Window;
|
|
//unsigned long id = (unsigned long)glfwGetX11Window(CORE.Window.handle);
|
|
//return NULL; // TODO: Find a way to return value... cast to void *?
|
|
return (void *)CORE.Window.handle;
|
|
#endif
|
|
#if defined(__APPLE__)
|
|
// NOTE: Returned handle is: (objc_object *)
|
|
return (void *)glfwGetCocoaWindow(CORE.Window.handle);
|
|
#endif
|
|
|
|
return NULL;
|
|
}
|
|
|
|
// Get number of monitors
|
|
int GetMonitorCount(void)
|
|
{
|
|
int monitorCount;
|
|
glfwGetMonitors(&monitorCount);
|
|
return monitorCount;
|
|
}
|
|
// Get number of monitors
|
|
int GetCurrentMonitor(void)
|
|
{
|
|
int index = 0;
|
|
int monitorCount;
|
|
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(CORE.Window.handle);
|
|
|
|
for (int i = 0; i < monitorCount; i++)
|
|
{
|
|
if (monitors[i] == monitor)
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
int x = 0;
|
|
int y = 0;
|
|
|
|
glfwGetWindowPos(CORE.Window.handle, &x, &y);
|
|
|
|
for (int i = 0; i < monitorCount; i++)
|
|
{
|
|
int mx = 0;
|
|
int my = 0;
|
|
|
|
monitor = monitors[i];
|
|
glfwGetMonitorPos(monitor, &mx, &my);
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitor);
|
|
if (mode)
|
|
{
|
|
const int width = mode->width;
|
|
const int height = mode->height;
|
|
|
|
if ((x >= mx) &&
|
|
(x < (mx + width)) &&
|
|
(y >= my) &&
|
|
(y < (my + height)))
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find video mode for selected monitor");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Get selected monitor position
|
|
Vector2 GetMonitorPosition(int monitor)
|
|
{
|
|
int monitorCount;
|
|
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 monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
|
|
if (mode) return 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 0;
|
|
}
|
|
|
|
|
|
// Get selected monitor height (currently used by monitor)
|
|
int GetMonitorHeight(int monitor)
|
|
{
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *mode = glfwGetVideoMode(monitors[monitor]);
|
|
|
|
if (mode) return 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 0;
|
|
}
|
|
|
|
// Get selected monitor physical height in millimetres
|
|
int GetMonitorPhysicalHeight(int monitor)
|
|
{
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
int physicalHeight;
|
|
glfwGetMonitorPhysicalSize(monitors[monitor], NULL, &physicalHeight);
|
|
return physicalHeight;
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
return 0;
|
|
}
|
|
|
|
// Get selected monitor refresh rate
|
|
int GetMonitorRefreshRate(int monitor)
|
|
{
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
const GLFWvidmode *vidmode = glfwGetVideoMode(monitors[monitor]);
|
|
return vidmode->refreshRate;
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
return 0;
|
|
}
|
|
|
|
// Get window position XY on monitor
|
|
Vector2 GetWindowPosition(void)
|
|
{
|
|
int x = 0;
|
|
int y = 0;
|
|
glfwGetWindowPos(CORE.Window.handle, &x, &y);
|
|
return (Vector2){ (float)x, (float)y };
|
|
}
|
|
|
|
|
|
// Get window scale DPI factor for current monitor
|
|
Vector2 GetWindowScaleDPI(void)
|
|
{
|
|
Vector2 scale = { 1.0f, 1.0f };
|
|
|
|
float xdpi = 1.0;
|
|
float ydpi = 1.0;
|
|
Vector2 windowPos = GetWindowPosition();
|
|
|
|
int monitorCount = 0;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
// Check window monitor
|
|
for (int i = 0; i < monitorCount; i++)
|
|
{
|
|
glfwGetMonitorContentScale(monitors[i], &xdpi, &ydpi);
|
|
|
|
int xpos, ypos, width, height;
|
|
glfwGetMonitorWorkarea(monitors[i], &xpos, &ypos, &width, &height);
|
|
|
|
if ((windowPos.x >= xpos) && (windowPos.x < xpos + width) &&
|
|
(windowPos.y >= ypos) && (windowPos.y < ypos + height))
|
|
{
|
|
scale.x = xdpi;
|
|
scale.y = ydpi;
|
|
break;
|
|
}
|
|
}
|
|
|
|
return scale;
|
|
}
|
|
|
|
|
|
// Get the human-readable, UTF-8 encoded name of the selected monitor
|
|
const char *GetMonitorName(int monitor)
|
|
{
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
return glfwGetMonitorName(monitors[monitor]);
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
return "";
|
|
}
|
|
|
|
|
|
// Set clipboard text content
|
|
void SetClipboardText(const char *text)
|
|
{
|
|
glfwSetClipboardString(CORE.Window.handle, text);
|
|
}
|
|
|
|
|
|
// Get clipboard text content
|
|
// NOTE: returned string is allocated and freed by GLFW
|
|
const char *GetClipboardText(void)
|
|
{
|
|
return glfwGetClipboardString(CORE.Window.handle);
|
|
}
|
|
|
|
// Show mouse cursor
|
|
void ShowCursor(void)
|
|
{
|
|
glfwSetInputMode(CORE.Window.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
|
|
CORE.Input.Mouse.cursorHidden = false;
|
|
}
|
|
|
|
// Hides mouse cursor
|
|
void HideCursor(void)
|
|
{
|
|
glfwSetInputMode(CORE.Window.handle, GLFW_CURSOR, GLFW_CURSOR_HIDDEN);
|
|
CORE.Input.Mouse.cursorHidden = true;
|
|
}
|
|
|
|
|
|
// Enables cursor (unlock cursor)
|
|
void EnableCursor(void)
|
|
{
|
|
glfwSetInputMode(CORE.Window.handle, GLFW_CURSOR, GLFW_CURSOR_NORMAL);
|
|
|
|
// Set cursor position in the middle
|
|
SetMousePosition(CORE.Window.screen.width/2, CORE.Window.screen.height/2);
|
|
|
|
CORE.Input.Mouse.cursorHidden = false;
|
|
}
|
|
|
|
// Disables cursor (lock cursor)
|
|
void DisableCursor(void)
|
|
{
|
|
glfwSetInputMode(CORE.Window.handle, GLFW_CURSOR, GLFW_CURSOR_DISABLED);
|
|
|
|
// Set cursor position in the middle
|
|
SetMousePosition(CORE.Window.screen.width/2, CORE.Window.screen.height/2);
|
|
|
|
CORE.Input.Mouse.cursorHidden = true;
|
|
}
|
|
|
|
|
|
// Get elapsed time measure in seconds since InitTimer()
|
|
// NOTE: On PLATFORM_DESKTOP InitTimer() is called on InitWindow()
|
|
// NOTE: On PLATFORM_DESKTOP, timer is initialized on glfwInit()
|
|
double GetTime(void)
|
|
{
|
|
double time = glfwGetTime(); // Elapsed time since glfwInit()
|
|
return time;
|
|
}
|
|
|
|
// NOTE TRACELOG() function is located in [utils.h]
|
|
|
|
// Takes a screenshot of current screen (saved a .png)
|
|
void TakeScreenshot(const char *fileName)
|
|
{
|
|
#if defined(SUPPORT_MODULE_RTEXTURES)
|
|
// Security check to (partially) avoid malicious code on PLATFORM_WEB
|
|
if (strchr(fileName, '\'') != NULL) { TRACELOG(LOG_WARNING, "SYSTEM: Provided fileName could be potentially malicious, avoid [\'] character"); return; }
|
|
|
|
Vector2 scale = GetWindowScaleDPI();
|
|
unsigned char *imgData = rlReadScreenPixels((int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y));
|
|
Image image = { imgData, (int)((float)CORE.Window.render.width*scale.x), (int)((float)CORE.Window.render.height*scale.y), 1, PIXELFORMAT_UNCOMPRESSED_R8G8B8A8 };
|
|
|
|
char path[2048] = { 0 };
|
|
strcpy(path, TextFormat("%s/%s", CORE.Storage.basePath, fileName));
|
|
|
|
ExportImage(image, path); // WARNING: Module required: rtextures
|
|
RL_FREE(imgData);
|
|
|
|
TRACELOG(LOG_INFO, "SYSTEM: [%s] Screenshot taken successfully", path);
|
|
#else
|
|
TRACELOG(LOG_WARNING,"IMAGE: ExportImage() requires module: rtextures");
|
|
#endif
|
|
}
|
|
|
|
// 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 on PLATFORM_WEB
|
|
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);
|
|
}
|
|
}
|
|
|
|
// Get gamepad internal name id
|
|
const char *GetGamepadName(int gamepad)
|
|
{
|
|
const char *name = NULL;
|
|
|
|
if (CORE.Input.Gamepad.ready[gamepad]) name = glfwGetJoystickName(gamepad);
|
|
|
|
return name;
|
|
}
|
|
|
|
// Get selected monitor physical width in millimetres
|
|
int GetMonitorPhysicalWidth(int monitor)
|
|
{
|
|
int monitorCount;
|
|
GLFWmonitor **monitors = glfwGetMonitors(&monitorCount);
|
|
|
|
if ((monitor >= 0) && (monitor < monitorCount))
|
|
{
|
|
int physicalWidth;
|
|
glfwGetMonitorPhysicalSize(monitors[monitor], &physicalWidth, NULL);
|
|
return physicalWidth;
|
|
}
|
|
else TRACELOG(LOG_WARNING, "GLFW: Failed to find selected monitor");
|
|
return 0;
|
|
}
|
|
|
|
// Get gamepad axis count
|
|
int GetGamepadAxisCount(int gamepad)
|
|
{
|
|
return CORE.Input.Gamepad.axisCount;
|
|
}
|
|
|
|
// Set internal gamepad mappings
|
|
int SetGamepadMappings(const char *mappings)
|
|
{
|
|
return glfwUpdateGamepadMappings(mappings);
|
|
}
|
|
|
|
// Get mouse position X
|
|
int GetMouseX(void)
|
|
{
|
|
return (int)((CORE.Input.Mouse.currentPosition.x + CORE.Input.Mouse.offset.x)*CORE.Input.Mouse.scale.x);
|
|
}
|
|
|
|
// Get mouse position Y
|
|
int GetMouseY(void)
|
|
{
|
|
return (int)((CORE.Input.Mouse.currentPosition.y + CORE.Input.Mouse.offset.y)*CORE.Input.Mouse.scale.y);
|
|
}
|
|
|
|
// Get mouse position XY
|
|
Vector2 GetMousePosition(void)
|
|
{
|
|
Vector2 position = { 0 };
|
|
|
|
position.x = (CORE.Input.Mouse.currentPosition.x + CORE.Input.Mouse.offset.x)*CORE.Input.Mouse.scale.x;
|
|
position.y = (CORE.Input.Mouse.currentPosition.y + CORE.Input.Mouse.offset.y)*CORE.Input.Mouse.scale.y;
|
|
|
|
return position;
|
|
}
|
|
|
|
// 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(CORE.Window.handle, CORE.Input.Mouse.currentPosition.x, CORE.Input.Mouse.currentPosition.y);
|
|
}
|
|
|
|
|
|
// Get mouse wheel movement Y
|
|
float GetMouseWheelMove(void)
|
|
{
|
|
float result = 0.0f;
|
|
|
|
if (fabsf(CORE.Input.Mouse.currentWheelMove.x) > fabsf(CORE.Input.Mouse.currentWheelMove.y)) result = (float)CORE.Input.Mouse.currentWheelMove.x;
|
|
else result = (float)CORE.Input.Mouse.currentWheelMove.y;
|
|
|
|
return result;
|
|
}
|
|
|
|
|
|
// Swap back buffer with front buffer (screen drawing)
|
|
void SwapScreenBuffer(void)
|
|
{
|
|
glfwSwapBuffers(CORE.Window.handle);
|
|
}
|
|
|
|
|
|
// 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 key repeats
|
|
for (int i = 0; i < MAX_KEYBOARD_KEYS; i++) CORE.Input.Keyboard.keyRepeatInFrame[i] = 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
|
|
// TODO: It resets on PLATFORM_WEB the mouse position and not filled again until a move-event,
|
|
// so, if mouse is not moved it returns a (0, 0) position... this behaviour should be reviewed!
|
|
//for (int i = 0; i < MAX_TOUCH_POINTS; i++) CORE.Input.Touch.position[i] = (Vector2){ 0, 0 };
|
|
|
|
// 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 < GLFW_GAMEPAD_BUTTON_DPAD_LEFT + 1) && (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 < MAX_GAMEPAD_AXIS); 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 = 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)
|
|
}
|