MrMonopoly/raylib
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

rename FLAG_CHECK() to FLAG_IS_SET()

Browse Source
This commit is contained in:
JohnnyCena123 2025-10-08 15:20:06 +03:00
parent fa4f7a203b
commit c10e3075bd
8 changed files with 242 additions and 242 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/platforms/rcore_android.c
View File

@ -887,7 +887,7 @@ static int InitGraphicsDevice(void)
EGLint samples = 0; EGLint samples = 0;
EGLint sampleBuffer = 0; EGLint sampleBuffer = 0;
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
samples = 4; samples = 4;
sampleBuffer = 1; sampleBuffer = 1;
@ -992,7 +992,7 @@ static int InitGraphicsDevice(void)
CORE.Window.ready = true; CORE.Window.ready = true;
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow(); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) MinimizeWindow();
return 0; return 0;
} }
@ -1059,7 +1059,7 @@ static void AndroidCommandCallback(struct android_app *app, int32_t cmd)
// Set font white rectangle for shapes drawing, so shapes and text can be batched together // 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 // WARNING: rshapes module is required, if not available, default internal white rectangle is used
Rectangle rec = GetFontDefault().recs[95]; Rectangle rec = GetFontDefault().recs[95];
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
// NOTE: We try to maxime rec padding to avoid pixel bleeding on MSAA filtering // 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 }); SetShapesTexture(GetFontDefault().texture, (Rectangle){ rec.x + 2, rec.y + 2, 1, 1 });
@ -1187,8 +1187,8 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event)
if (type == AINPUT_EVENT_TYPE_MOTION) if (type == AINPUT_EVENT_TYPE_MOTION)
{ {
if ((FLAG_CHECK(source, AINPUT_SOURCE_JOYSTICK) == AINPUT_SOURCE_JOYSTICK) || if ((FLAG_IS_SET(source, AINPUT_SOURCE_JOYSTICK) == AINPUT_SOURCE_JOYSTICK) ||
(FLAG_CHECK(source, AINPUT_SOURCE_GAMEPAD) == AINPUT_SOURCE_GAMEPAD)) (FLAG_IS_SET(source, AINPUT_SOURCE_GAMEPAD) == AINPUT_SOURCE_GAMEPAD))
{ {
// For now we'll assume a single gamepad which we "detect" on its input event // For now we'll assume a single gamepad which we "detect" on its input event
CORE.Input.Gamepad.ready[0] = true; CORE.Input.Gamepad.ready[0] = true;
@ -1251,8 +1251,8 @@ static int32_t AndroidInputCallback(struct android_app *app, AInputEvent *event)
//int32_t AKeyEvent_getMetaState(event); //int32_t AKeyEvent_getMetaState(event);
// Handle gamepad button presses and releases // Handle gamepad button presses and releases
if ((FLAG_CHECK(source, AINPUT_SOURCE_JOYSTICK) == AINPUT_SOURCE_JOYSTICK) || if ((FLAG_IS_SET(source, AINPUT_SOURCE_JOYSTICK) == AINPUT_SOURCE_JOYSTICK) ||
(FLAG_CHECK(source, AINPUT_SOURCE_GAMEPAD) == AINPUT_SOURCE_GAMEPAD)) (FLAG_IS_SET(source, AINPUT_SOURCE_GAMEPAD) == AINPUT_SOURCE_GAMEPAD))
{ {
// For now we'll assume a single gamepad which we "detect" on its input event // For now we'll assume a single gamepad which we "detect" on its input event
CORE.Input.Gamepad.ready[0] = true; CORE.Input.Gamepad.ready[0] = true;

102
src/platforms/rcore_desktop_glfw.c
View File

@ -218,7 +218,7 @@ void ToggleFullscreen(void)
// Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS) // 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 // NOTE: V-Sync can be enabled by graphic driver configuration
if (FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT)) glfwSwapInterval(1); if (FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT)) glfwSwapInterval(1);
} }
// Toggle borderless windowed mode // Toggle borderless windowed mode
@ -333,7 +333,7 @@ void SetWindowState(unsigned int flags)
// NOTE: In most cases the functions already change the flags internally // NOTE: In most cases the functions already change the flags internally
// State change: FLAG_VSYNC_HINT // State change: FLAG_VSYNC_HINT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT) != FLAG_CHECK(flags, FLAG_VSYNC_HINT)) && FLAG_CHECK(flags, FLAG_VSYNC_HINT) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT) != FLAG_IS_SET(flags, FLAG_VSYNC_HINT)) && FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
glfwSwapInterval(1); glfwSwapInterval(1);
FLAG_SET(CORE.Window.flags, FLAG_VSYNC_HINT); FLAG_SET(CORE.Window.flags, FLAG_VSYNC_HINT);
@ -341,68 +341,68 @@ void SetWindowState(unsigned int flags)
// State change: FLAG_BORDERLESS_WINDOWED_MODE // 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 // NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
if ((FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) != FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE)) && FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) != FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE)) && FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_FULLSCREEN_MODE // State change: FLAG_FULLSCREEN_MODE
if ((FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) != FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE)) && FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE) != FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE)) && FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
ToggleFullscreen(); // NOTE: Window state flag updated inside function ToggleFullscreen(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_WINDOW_RESIZABLE // State change: FLAG_WINDOW_RESIZABLE
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE)) && FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE)) && FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_TRUE); glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_TRUE);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE);
} }
// State change: FLAG_WINDOW_UNDECORATED // State change: FLAG_WINDOW_UNDECORATED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNDECORATED) != FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED)) && FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED) != FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED)) && FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_FALSE); glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_FALSE);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED);
} }
// State change: FLAG_WINDOW_HIDDEN // State change: FLAG_WINDOW_HIDDEN
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) != FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN)) && FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN) != FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN)) && FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
glfwHideWindow(platform.handle); glfwHideWindow(platform.handle);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN);
} }
// State change: FLAG_WINDOW_MINIMIZED // State change: FLAG_WINDOW_MINIMIZED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) != FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED)) && FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) != FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED)) && FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
//GLFW_ICONIFIED //GLFW_ICONIFIED
MinimizeWindow(); // NOTE: Window state flag updated inside function MinimizeWindow(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_WINDOW_MAXIMIZED // State change: FLAG_WINDOW_MAXIMIZED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) != FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED)) && FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) != FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED)) && FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED))
{ {
//GLFW_MAXIMIZED //GLFW_MAXIMIZED
MaximizeWindow(); // NOTE: Window state flag updated inside function MaximizeWindow(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_WINDOW_UNFOCUSED // State change: FLAG_WINDOW_UNFOCUSED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) != FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED)) && FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) != FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED)) && FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_FALSE); glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_FALSE);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED);
} }
// State change: FLAG_WINDOW_TOPMOST // State change: FLAG_WINDOW_TOPMOST
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TOPMOST) != FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST)) && FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST) != FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST)) && FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_TRUE); glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_TRUE);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST);
} }
// State change: FLAG_WINDOW_ALWAYS_RUN // State change: FLAG_WINDOW_ALWAYS_RUN
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN) != FLAG_CHECK(flags, FLAG_WINDOW_ALWAYS_RUN)) && FLAG_CHECK(flags, FLAG_WINDOW_ALWAYS_RUN) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN) != FLAG_IS_SET(flags, FLAG_WINDOW_ALWAYS_RUN)) && FLAG_IS_SET(flags, FLAG_WINDOW_ALWAYS_RUN))
{ {
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN);
} }
@ -410,32 +410,32 @@ void SetWindowState(unsigned int flags)
// The following states can not be changed after window creation // The following states can not be changed after window creation
// State change: FLAG_WINDOW_TRANSPARENT // State change: FLAG_WINDOW_TRANSPARENT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT) != FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT)) && FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT) != FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT)) && FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
} }
// State change: FLAG_WINDOW_HIGHDPI // State change: FLAG_WINDOW_HIGHDPI
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) != FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI)) && FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) != FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI)) && FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI))
{ {
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
} }
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH // State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) != FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) && FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) != FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) && FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE); glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH);
} }
// State change: FLAG_MSAA_4X_HINT // State change: FLAG_MSAA_4X_HINT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) != FLAG_CHECK(flags, FLAG_MSAA_4X_HINT)) && FLAG_CHECK(flags, FLAG_MSAA_4X_HINT) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT) != FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT)) && FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
} }
// State change: FLAG_INTERLACED_HINT // State change: FLAG_INTERLACED_HINT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_INTERLACED_HINT) != FLAG_CHECK(flags, FLAG_INTERLACED_HINT)) && FLAG_CHECK(flags, FLAG_INTERLACED_HINT) > 0) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_INTERLACED_HINT) != FLAG_IS_SET(flags, FLAG_INTERLACED_HINT)) && FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "WINDOW: Interlaced mode can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: Interlaced mode can only be configured before window initialization");
} }
@ -448,7 +448,7 @@ void ClearWindowState(unsigned int flags)
// NOTE: In most cases the functions already change the flags internally // NOTE: In most cases the functions already change the flags internally
// State change: FLAG_VSYNC_HINT // State change: FLAG_VSYNC_HINT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT) > 0) && (FLAG_CHECK(flags, FLAG_VSYNC_HINT) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT)) && (FLAG_IS_SET(flags, FLAG_VSYNC_HINT)))
{ {
glfwSwapInterval(0); glfwSwapInterval(0);
FLAG_CLEAR(CORE.Window.flags, FLAG_VSYNC_HINT); FLAG_CLEAR(CORE.Window.flags, FLAG_VSYNC_HINT);
@ -456,66 +456,66 @@ void ClearWindowState(unsigned int flags)
// State change: FLAG_BORDERLESS_WINDOWED_MODE // 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 // NOTE: This must be handled before FLAG_FULLSCREEN_MODE because ToggleBorderlessWindowed() needs to get some fullscreen values if fullscreen is running
if ((FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0) && (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE)) && (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE)))
{ {
ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function ToggleBorderlessWindowed(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_FULLSCREEN_MODE // State change: FLAG_FULLSCREEN_MODE
if ((FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) && (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) && (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE)))
{ {
ToggleFullscreen(); // NOTE: Window state flag updated inside function ToggleFullscreen(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_WINDOW_RESIZABLE // State change: FLAG_WINDOW_RESIZABLE
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) && (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_FALSE); glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_FALSE);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_RESIZABLE); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_RESIZABLE);
} }
// State change: FLAG_WINDOW_HIDDEN // State change: FLAG_WINDOW_HIDDEN
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) && (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN)))
{ {
glfwShowWindow(platform.handle); glfwShowWindow(platform.handle);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_HIDDEN); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_HIDDEN);
} }
// State change: FLAG_WINDOW_MINIMIZED // State change: FLAG_WINDOW_MINIMIZED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) && (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED)))
{ {
RestoreWindow(); // NOTE: Window state flag updated inside function RestoreWindow(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_WINDOW_MAXIMIZED // State change: FLAG_WINDOW_MAXIMIZED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) && (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED)))
{ {
RestoreWindow(); // NOTE: Window state flag updated inside function RestoreWindow(); // NOTE: Window state flag updated inside function
} }
// State change: FLAG_WINDOW_UNDECORATED // State change: FLAG_WINDOW_UNDECORATED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNDECORATED) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) && (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_TRUE); glfwSetWindowAttrib(platform.handle, GLFW_DECORATED, GLFW_TRUE);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNDECORATED); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNDECORATED);
} }
// State change: FLAG_WINDOW_UNFOCUSED // State change: FLAG_WINDOW_UNFOCUSED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) && (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_TRUE); glfwSetWindowAttrib(platform.handle, GLFW_FOCUS_ON_SHOW, GLFW_TRUE);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED);
} }
// State change: FLAG_WINDOW_TOPMOST // State change: FLAG_WINDOW_TOPMOST
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TOPMOST) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST)) && (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_FALSE); glfwSetWindowAttrib(platform.handle, GLFW_FLOATING, GLFW_FALSE);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_TOPMOST); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_TOPMOST);
} }
// State change: FLAG_WINDOW_ALWAYS_RUN // State change: FLAG_WINDOW_ALWAYS_RUN
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_ALWAYS_RUN) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN)) && (FLAG_IS_SET(flags, FLAG_WINDOW_ALWAYS_RUN)))
{ {
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN);
} }
@ -523,32 +523,32 @@ void ClearWindowState(unsigned int flags)
// The following states can not be changed after window creation // The following states can not be changed after window creation
// State change: FLAG_WINDOW_TRANSPARENT // State change: FLAG_WINDOW_TRANSPARENT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT)) && (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT)))
{ {
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
} }
// State change: FLAG_WINDOW_HIGHDPI // State change: FLAG_WINDOW_HIGHDPI
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)) && (FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI)))
{ {
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
} }
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH // State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) && (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE); glfwSetWindowAttrib(platform.handle, GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH);
} }
// State change: FLAG_MSAA_4X_HINT // State change: FLAG_MSAA_4X_HINT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) && (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT)) && (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT)))
{ {
TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: MSAA can only be configured before window initialization");
} }
// State change: FLAG_INTERLACED_HINT // State change: FLAG_INTERLACED_HINT
if ((FLAG_CHECK(CORE.Window.flags, FLAG_INTERLACED_HINT) > 0) && (FLAG_CHECK(flags, FLAG_INTERLACED_HINT) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_INTERLACED_HINT)) && (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT)))
{ {
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization"); TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
} }
@ -1385,31 +1385,31 @@ int InitPlatform(void)
unsigned int requestedWindowFlags = CORE.Window.flags; unsigned int requestedWindowFlags = CORE.Window.flags;
// Check window creation flags // Check window creation flags
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true; if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) CORE.Window.fullscreen = true;
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) > 0) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window
else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNDECORATED) > 0) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window
else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) > 0) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window
else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable
// Disable FLAG_WINDOW_MINIMIZED, not supported on initialization // Disable FLAG_WINDOW_MINIMIZED, not supported on initialization
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);
// Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization // Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) > 0) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE); else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TOPMOST) > 0) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST)) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE); else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
// NOTE: Some GLFW flags are not supported on HTML5 // NOTE: Some GLFW flags are not supported on HTML5
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT) > 0) glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); // Transparent framebuffer if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT)) glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_TRUE); // Transparent framebuffer
else glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_FALSE); // Opaque framebuffer else glfwWindowHint(GLFW_TRANSPARENT_FRAMEBUFFER, GLFW_FALSE); // Opaque framebuffer
// HACK: Most of this was written before GLFW_SCALE_FRAMEBUFFER existed and // HACK: Most of this was written before GLFW_SCALE_FRAMEBUFFER existed and
@ -1422,7 +1422,7 @@ int InitPlatform(void)
glfwWindowHint(GLFW_SCALE_FRAMEBUFFER, GLFW_FALSE); glfwWindowHint(GLFW_SCALE_FRAMEBUFFER, GLFW_FALSE);
#endif #endif
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
// since we skipped it before, now make sure to set this on macOS // since we skipped it before, now make sure to set this on macOS
#if defined(__APPLE__) #if defined(__APPLE__)
@ -1439,10 +1439,10 @@ int InitPlatform(void)
else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE); else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
// Mouse passthrough // Mouse passthrough
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_TRUE);
else glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE); else glfwWindowHint(GLFW_MOUSE_PASSTHROUGH, GLFW_FALSE);
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
// NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs // NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4"); TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
@ -1634,7 +1634,7 @@ int InitPlatform(void)
// Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS) // 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 // 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 // to be activated on web platforms since VSync is enforced there
if (FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT)) if (FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT))
{ {
// WARNING: It seems to hit a critical render path in Intel HD Graphics // WARNING: It seems to hit a critical render path in Intel HD Graphics
glfwSwapInterval(1); glfwSwapInterval(1);
@ -1644,7 +1644,7 @@ int InitPlatform(void)
int fbWidth = CORE.Window.screen.width; int fbWidth = CORE.Window.screen.width;
int fbHeight = CORE.Window.screen.height; int fbHeight = CORE.Window.screen.height;
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
// NOTE: On APPLE platforms system should manage window/input scaling and also framebuffer scaling // NOTE: On APPLE platforms system should manage window/input scaling and also framebuffer scaling
// Framebuffer scaling should be activated with: glfwWindowHint(GLFW_SCALE_FRAMEBUFFER, GLFW_TRUE); // Framebuffer scaling should be activated with: glfwWindowHint(GLFW_SCALE_FRAMEBUFFER, GLFW_TRUE);
@ -1676,7 +1676,7 @@ int InitPlatform(void)
return -1; return -1;
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow(); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) MinimizeWindow();
// If graphic device is no properly initialized, we end program // If graphic device is no properly initialized, we end program
if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; } if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; }
@ -1720,7 +1720,7 @@ int InitPlatform(void)
glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback); glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback);
glfwSetDropCallback(platform.handle, WindowDropCallback); glfwSetDropCallback(platform.handle, WindowDropCallback);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
glfwSetWindowContentScaleCallback(platform.handle, WindowContentScaleCallback); glfwSetWindowContentScaleCallback(platform.handle, WindowContentScaleCallback);
} }
@ -1899,8 +1899,8 @@ static void KeyCallback(GLFWwindow *window, int key, int scancode, int action, i
else if (action == GLFW_REPEAT) CORE.Input.Keyboard.keyRepeatInFrame[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 // WARNING: Check if CAPS/NUM key modifiers are enabled and force down state for those keys
if (((key == KEY_CAPS_LOCK) && (FLAG_CHECK(mods, GLFW_MOD_CAPS_LOCK) > 0)) || if (((key == KEY_CAPS_LOCK) && (FLAG_IS_SET(mods, GLFW_MOD_CAPS_LOCK))) ||
((key == KEY_NUM_LOCK) && (FLAG_CHECK(mods, GLFW_MOD_NUM_LOCK) > 0))) CORE.Input.Keyboard.currentKeyState[key] = 1; ((key == KEY_NUM_LOCK) && (FLAG_IS_SET(mods, GLFW_MOD_NUM_LOCK)))) CORE.Input.Keyboard.currentKeyState[key] = 1;
// Check if there is space available in the key queue // Check if there is space available in the key queue
if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS)) if ((CORE.Input.Keyboard.keyPressedQueueCount < MAX_KEY_PRESSED_QUEUE) && (action == GLFW_PRESS))

96
src/platforms/rcore_desktop_rgfw.c
View File

@ -324,7 +324,7 @@ void ToggleFullscreen(void)
// Try to enable GPU V-Sync, so frames are limited to screen refresh rate (60Hz -> 60 FPS) // 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 // NOTE: V-Sync can be enabled by graphic driver configuration
if (FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT) > 0) RGFW_window_swapInterval(platform.window, 1); if (FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT)) RGFW_window_swapInterval(platform.window, 1);
} }
// Toggle borderless windowed mode // Toggle borderless windowed mode
@ -366,7 +366,7 @@ void MinimizeWindow(void)
// Restore window from being minimized/maximized // Restore window from being minimized/maximized
void RestoreWindow(void) void RestoreWindow(void)
{ {
if (!FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window);
RGFW_window_restore(platform.window); RGFW_window_restore(platform.window);
} }
@ -378,66 +378,66 @@ void SetWindowState(unsigned int flags)
FLAG_SET(CORE.Window.flags, flags); FLAG_SET(CORE.Window.flags, flags);
if (FLAG_CHECK(flags, FLAG_VSYNC_HINT)) if (FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
RGFW_window_swapInterval(platform.window, 1); RGFW_window_swapInterval(platform.window, 1);
} }
if (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE)) if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
if (!CORE.Window.fullscreen) ToggleFullscreen(); if (!CORE.Window.fullscreen) ToggleFullscreen();
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE)) if (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE))
{ {
RGFW_window_setMaxSize(platform.window, RGFW_AREA(0, 0)); RGFW_window_setMaxSize(platform.window, RGFW_AREA(0, 0));
RGFW_window_setMinSize(platform.window, RGFW_AREA(0, 0)); RGFW_window_setMinSize(platform.window, RGFW_AREA(0, 0));
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
RGFW_window_setBorder(platform.window, 0); RGFW_window_setBorder(platform.window, 0);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
RGFW_window_hide(platform.window); RGFW_window_hide(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
RGFW_window_minimize(platform.window); RGFW_window_minimize(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED))
{ {
RGFW_window_maximize(platform.window); RGFW_window_maximize(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED);
FLAG_CLEAR(platform.window->_flags, RGFW_windowFocusOnShow); FLAG_CLEAR(platform.window->_flags, RGFW_windowFocusOnShow);
RGFW_window_setFlags(platform.window, platform.window->_flags); RGFW_window_setFlags(platform.window, platform.window->_flags);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
RGFW_window_setFloating(platform.window, RGFW_TRUE); RGFW_window_setFloating(platform.window, RGFW_TRUE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI))
{ {
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
RGFW_window_setMousePassthrough(platform.window, 1); RGFW_window_setMousePassthrough(platform.window, 1);
} }
if (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE)) if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
ToggleBorderlessWindowed(); ToggleBorderlessWindowed();
} }
if (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
RGFW_setGLHint(RGFW_glSamples, 4); RGFW_setGLHint(RGFW_glSamples, 4);
} }
if (FLAG_CHECK(flags, FLAG_INTERLACED_HINT)) if (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization"); TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
} }
@ -448,70 +448,70 @@ void ClearWindowState(unsigned int flags)
{ {
FLAG_CLEAR(CORE.Window.flags, flags); FLAG_CLEAR(CORE.Window.flags, flags);
if (FLAG_CHECK(flags, FLAG_VSYNC_HINT)) if (FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
RGFW_window_swapInterval(platform.window, 0); RGFW_window_swapInterval(platform.window, 0);
} }
if (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE)) if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
if (CORE.Window.fullscreen) ToggleFullscreen(); if (CORE.Window.fullscreen) ToggleFullscreen();
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE)) if (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE))
{ {
RGFW_window_setMaxSize(platform.window, RGFW_AREA(platform.window->r.w, platform.window->r.h)); RGFW_window_setMaxSize(platform.window, RGFW_AREA(platform.window->r.w, platform.window->r.h));
RGFW_window_setMinSize(platform.window, RGFW_AREA(platform.window->r.w, platform.window->r.h)); RGFW_window_setMinSize(platform.window, RGFW_AREA(platform.window->r.w, platform.window->r.h));
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
RGFW_window_setBorder(platform.window, 1); RGFW_window_setBorder(platform.window, 1);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
if (!FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window);
RGFW_window_show(platform.window); RGFW_window_show(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
if (!FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window);
RGFW_window_restore(platform.window); RGFW_window_restore(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED))
{ {
if (!FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) RGFW_window_focus(platform.window);
RGFW_window_restore(platform.window); RGFW_window_restore(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
RGFW_window_setFlags(platform.window, platform.window->_flags | RGFW_windowFocusOnShow); RGFW_window_setFlags(platform.window, platform.window->_flags | RGFW_windowFocusOnShow);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
RGFW_window_setFloating(platform.window, RGFW_FALSE); RGFW_window_setFloating(platform.window, RGFW_FALSE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: Framebuffer transparency can only be configured before window initialization");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI))
{ {
TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization"); TRACELOG(LOG_WARNING, "WINDOW: High DPI can only be configured before window initialization");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
RGFW_window_setMousePassthrough(platform.window, 0); RGFW_window_setMousePassthrough(platform.window, 0);
} }
if (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE)) if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
if (CORE.Window.fullscreen) ToggleBorderlessWindowed(); if (CORE.Window.fullscreen) ToggleBorderlessWindowed();
} }
if (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
RGFW_setGLHint(RGFW_glSamples, 0); RGFW_setGLHint(RGFW_glSamples, 0);
} }
if (FLAG_CHECK(flags, FLAG_INTERLACED_HINT)) if (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization"); TRACELOG(LOG_WARNING, "RPI: Interlaced mode can only be configured before window initialization");
} }
@ -968,7 +968,7 @@ void PollInputEvents(void)
CORE.Window.resizedLastFrame = false; CORE.Window.resizedLastFrame = false;
CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition; CORE.Input.Mouse.previousPosition = CORE.Input.Mouse.currentPosition;
if (FLAG_CHECK(platform.window->_flags, RGFW_HOLD_MOUSE)) if (FLAG_IS_SET(platform.window->_flags, RGFW_HOLD_MOUSE))
{ {
CORE.Input.Mouse.previousPosition = (Vector2){ 0.0f, 0.0f }; CORE.Input.Mouse.previousPosition = (Vector2){ 0.0f, 0.0f };
CORE.Input.Mouse.currentPosition = (Vector2){ 0.0f, 0.0f }; CORE.Input.Mouse.currentPosition = (Vector2){ 0.0f, 0.0f };
@ -1144,7 +1144,7 @@ void PollInputEvents(void)
} break; } break;
case RGFW_mousePosChanged: case RGFW_mousePosChanged:
{ {
if (FLAG_CHECK(platform.window->_flags, RGFW_HOLD_MOUSE)) if (FLAG_IS_SET(platform.window->_flags, RGFW_HOLD_MOUSE))
{ {
CORE.Input.Mouse.currentPosition.x += (float)event->vector.x; CORE.Input.Mouse.currentPosition.x += (float)event->vector.x;
CORE.Input.Mouse.currentPosition.y += (float)event->vector.y; CORE.Input.Mouse.currentPosition.y += (float)event->vector.y;
@ -1268,24 +1268,24 @@ int InitPlatform(void)
unsigned int flags = RGFW_windowCenter | RGFW_windowAllowDND; unsigned int flags = RGFW_windowCenter | RGFW_windowAllowDND;
// Check window creation flags // Check window creation flags
if ((FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE))
{ {
CORE.Window.fullscreen = true; CORE.Window.fullscreen = true;
FLAG_SET(flags, RGFW_windowFullscreen); FLAG_SET(flags, RGFW_windowFullscreen);
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
CORE.Window.fullscreen = true; CORE.Window.fullscreen = true;
FLAG_SET(flags, RGFW_windowedFullscreen); FLAG_SET(flags, RGFW_windowedFullscreen);
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNDECORATED) > 0) FLAG_SET(flags, RGFW_windowNoBorder); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) FLAG_SET(flags, RGFW_windowNoBorder);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) == 0) FLAG_SET(flags, RGFW_windowNoResize); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) FLAG_SET(flags, RGFW_windowNoResize);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT) > 0) FLAG_SET(flags, RGFW_windowTransparent); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT)) FLAG_SET(flags, RGFW_windowTransparent);
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) FLAG_SET(flags, RGFW_windowFullscreen); if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) FLAG_SET(flags, RGFW_windowFullscreen);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) > 0) FLAG_SET(flags, RGFW_windowHide); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) FLAG_SET(flags, RGFW_windowHide);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0) FLAG_SET(flags, RGFW_windowMaximize); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_SET(flags, RGFW_windowMaximize);
// NOTE: Some OpenGL context attributes must be set before window creation // NOTE: Some OpenGL context attributes must be set before window creation
// Check selection OpenGL version // Check selection OpenGL version
@ -1305,9 +1305,9 @@ int InitPlatform(void)
RGFW_setGLHint(RGFW_glMinor, 3); RGFW_setGLHint(RGFW_glMinor, 3);
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) RGFW_setGLHint(RGFW_glSamples, 4); if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT)) RGFW_setGLHint(RGFW_glSamples, 4);
if (!FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) FLAG_SET(flags, RGFW_windowFocusOnShow | RGFW_windowFocus); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) FLAG_SET(flags, RGFW_windowFocusOnShow | RGFW_windowFocus);
platform.window = RGFW_createWindow(CORE.Window.title, RGFW_RECT(0, 0, CORE.Window.screen.width, CORE.Window.screen.height), flags); platform.window = RGFW_createWindow(CORE.Window.title, RGFW_RECT(0, 0, CORE.Window.screen.width, CORE.Window.screen.height), flags);
platform.mon.mode.area.w = 0; platform.mon.mode.area.w = 0;
@ -1331,7 +1331,7 @@ int InitPlatform(void)
// If so, rcore_desktop_sdl should be updated too // If so, rcore_desktop_sdl should be updated too
//SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height); //SetupFramebuffer(CORE.Window.display.width, CORE.Window.display.height);
if (FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT)) RGFW_window_swapInterval(platform.window, 1); if (FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT)) RGFW_window_swapInterval(platform.window, 1);
RGFW_window_makeCurrent(platform.window); RGFW_window_makeCurrent(platform.window);
// Check surface and context activation // Check surface and context activation

120
src/platforms/rcore_desktop_sdl.c
View File

@ -469,7 +469,7 @@ void ToggleFullscreen(void)
if ((monitor >= 0) && (monitor < monitorCount)) if ((monitor >= 0) && (monitor < monitorCount))
#endif #endif
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE))
{ {
SDL_SetWindowFullscreen(platform.window, 0); SDL_SetWindowFullscreen(platform.window, 0);
FLAG_CLEAR(CORE.Window.flags, FLAG_FULLSCREEN_MODE); FLAG_CLEAR(CORE.Window.flags, FLAG_FULLSCREEN_MODE);
@ -497,7 +497,7 @@ void ToggleBorderlessWindowed(void)
if ((monitor >= 0) && (monitor < monitorCount)) if ((monitor >= 0) && (monitor < monitorCount))
#endif #endif
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
SDL_SetWindowFullscreen(platform.window, 0); SDL_SetWindowFullscreen(platform.window, 0);
FLAG_CLEAR(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE); FLAG_CLEAR(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE);
@ -515,14 +515,14 @@ void ToggleBorderlessWindowed(void)
void MaximizeWindow(void) void MaximizeWindow(void)
{ {
SDL_MaximizeWindow(platform.window); SDL_MaximizeWindow(platform.window);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) == 0) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);
} }
// Set window state: minimized // Set window state: minimized
void MinimizeWindow(void) void MinimizeWindow(void)
{ {
SDL_MinimizeWindow(platform.window); SDL_MinimizeWindow(platform.window);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) == 0) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);
} }
// Restore window from being minimized/maximized // Restore window from being minimized/maximized
@ -539,11 +539,11 @@ void SetWindowState(unsigned int flags)
FLAG_SET(CORE.Window.flags, flags); FLAG_SET(CORE.Window.flags, flags);
if (FLAG_CHECK(flags, FLAG_VSYNC_HINT)) if (FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
SDL_GL_SetSwapInterval(1); SDL_GL_SetSwapInterval(1);
} }
if (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE)) if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
const int monitor = SDL_GetWindowDisplayIndex(platform.window); const int monitor = SDL_GetWindowDisplayIndex(platform.window);
const int monitorCount = SDL_GetNumVideoDisplays(); const int monitorCount = SDL_GetNumVideoDisplays();
@ -559,51 +559,51 @@ void SetWindowState(unsigned int flags)
} }
else TRACELOG(LOG_WARNING, "SDL: Failed to find selected monitor"); else TRACELOG(LOG_WARNING, "SDL: Failed to find selected monitor");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE)) if (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE))
{ {
SDL_SetWindowResizable(platform.window, SDL_TRUE); SDL_SetWindowResizable(platform.window, SDL_TRUE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
SDL_SetWindowBordered(platform.window, SDL_FALSE); SDL_SetWindowBordered(platform.window, SDL_FALSE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
SDL_HideWindow(platform.window); SDL_HideWindow(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
SDL_MinimizeWindow(platform.window); SDL_MinimizeWindow(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED))
{ {
SDL_MaximizeWindow(platform.window); SDL_MaximizeWindow(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
// NOTE: To be able to implement this part it seems that we should // NOTE: To be able to implement this part it seems that we should
// do it ourselves, via 'windows.h', 'X11/Xlib.h' or even 'Cocoa.h' // do it ourselves, via 'windows.h', 'X11/Xlib.h' or even 'Cocoa.h'
TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_UNFOCUSED is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_UNFOCUSED is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
SDL_SetWindowAlwaysOnTop(platform.window, SDL_FALSE); SDL_SetWindowAlwaysOnTop(platform.window, SDL_FALSE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_TRANSPARENT is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_TRANSPARENT is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI))
{ {
// NOTE: Such a function does not seem to exist // NOTE: Such a function does not seem to exist
TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_HIGHDPI is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_HIGHDPI is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
//SDL_SetWindowGrab(platform.window, SDL_FALSE); //SDL_SetWindowGrab(platform.window, SDL_FALSE);
TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_MOUSE_PASSTHROUGH is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_WINDOW_MOUSE_PASSTHROUGH is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE)) if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
const int monitor = SDL_GetWindowDisplayIndex(platform.window); const int monitor = SDL_GetWindowDisplayIndex(platform.window);
const int monitorCount = SDL_GetNumVideoDisplays(); const int monitorCount = SDL_GetNumVideoDisplays();
@ -618,12 +618,12 @@ void SetWindowState(unsigned int flags)
} }
else TRACELOG(LOG_WARNING, "SDL: Failed to find selected monitor"); else TRACELOG(LOG_WARNING, "SDL: Failed to find selected monitor");
} }
if (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); // Enable multisampling buffers SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); // Enable multisampling buffers
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); // Enable multisampling SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); // Enable multisampling
} }
if (FLAG_CHECK(flags, FLAG_INTERLACED_HINT)) if (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_INTERLACED_HINT is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "SetWindowState() - FLAG_INTERLACED_HINT is not supported on PLATFORM_DESKTOP_SDL");
} }
@ -634,45 +634,45 @@ void ClearWindowState(unsigned int flags)
{ {
FLAG_CLEAR(CORE.Window.flags, flags); FLAG_CLEAR(CORE.Window.flags, flags);
if (FLAG_CHECK(flags, FLAG_VSYNC_HINT)) if (FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
SDL_GL_SetSwapInterval(0); SDL_GL_SetSwapInterval(0);
} }
if (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE)) if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
SDL_SetWindowFullscreen(platform.window, 0); SDL_SetWindowFullscreen(platform.window, 0);
CORE.Window.fullscreen = false; CORE.Window.fullscreen = false;
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE)) if (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE))
{ {
SDL_SetWindowResizable(platform.window, SDL_FALSE); SDL_SetWindowResizable(platform.window, SDL_FALSE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
SDL_SetWindowBordered(platform.window, SDL_TRUE); SDL_SetWindowBordered(platform.window, SDL_TRUE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN)) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
SDL_ShowWindow(platform.window); SDL_ShowWindow(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
SDL_RestoreWindow(platform.window); SDL_RestoreWindow(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED))
{ {
SDL_RestoreWindow(platform.window); SDL_RestoreWindow(platform.window);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED)) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
//SDL_RaiseWindow(platform.window); //SDL_RaiseWindow(platform.window);
TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_UNFOCUSED is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_UNFOCUSED is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
SDL_SetWindowAlwaysOnTop(platform.window, SDL_FALSE); SDL_SetWindowAlwaysOnTop(platform.window, SDL_FALSE);
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT)) if (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_TRANSPARENT is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_TRANSPARENT is not supported on PLATFORM_DESKTOP_SDL");
} }
@ -680,21 +680,21 @@ void ClearWindowState(unsigned int flags)
// NOTE: There also doesn't seem to be a feature to disable high DPI once enabled // NOTE: There also doesn't seem to be a feature to disable high DPI once enabled
TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_HIGHDPI is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_HIGHDPI is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) if (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
//SDL_SetWindowGrab(platform.window, SDL_TRUE); //SDL_SetWindowGrab(platform.window, SDL_TRUE);
TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_MOUSE_PASSTHROUGH is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_WINDOW_MOUSE_PASSTHROUGH is not supported on PLATFORM_DESKTOP_SDL");
} }
if (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE)) if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
SDL_SetWindowFullscreen(platform.window, 0); SDL_SetWindowFullscreen(platform.window, 0);
} }
if (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0); // Disable multisampling buffers SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 0); // Disable multisampling buffers
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0); // Disable multisampling SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 0); // Disable multisampling
} }
if (FLAG_CHECK(flags, FLAG_INTERLACED_HINT)) if (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_INTERLACED_HINT is not supported on PLATFORM_DESKTOP_SDL"); TRACELOG(LOG_WARNING, "ClearWindowState() - FLAG_INTERLACED_HINT is not supported on PLATFORM_DESKTOP_SDL");
} }
@ -835,7 +835,7 @@ void SetWindowMonitor(int monitor)
// 1. SDL started supporting moving exclusive fullscreen windows between displays on SDL3, // 1. SDL started supporting moving exclusive fullscreen windows between displays on SDL3,
// see commit https://github.com/libsdl-org/SDL/commit/3f5ef7dd422057edbcf3e736107e34be4b75d9ba // see commit https://github.com/libsdl-org/SDL/commit/3f5ef7dd422057edbcf3e736107e34be4b75d9ba
// 2. A workaround for SDL2 is leaving fullscreen, moving the window, then entering full screen again // 2. A workaround for SDL2 is leaving fullscreen, moving the window, then entering full screen again
const bool wasFullscreen = (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0)? true : false; const bool wasFullscreen = (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE))? true : false;
const int screenWidth = CORE.Window.screen.width; const int screenWidth = CORE.Window.screen.width;
const int screenHeight = CORE.Window.screen.height; const int screenHeight = CORE.Window.screen.height;
@ -1368,7 +1368,7 @@ void PollInputEvents(void)
CORE.Window.resizedLastFrame = false; CORE.Window.resizedLastFrame = false;
if ((CORE.Window.eventWaiting) || (FLAG_CHECK((CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) && (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN) == 0))) if ((CORE.Window.eventWaiting) || FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) && !FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_ALWAYS_RUN))
{ {
SDL_WaitEvent(NULL); SDL_WaitEvent(NULL);
CORE.Time.previous = GetTime(); CORE.Time.previous = GetTime();
@ -1456,7 +1456,7 @@ void PollInputEvents(void)
#ifndef USING_VERSION_SDL3 #ifndef USING_VERSION_SDL3
// Manually detect if the window was maximized (due to SDL2 restore being unreliable on some platforms) to remove the FLAG_WINDOW_MAXIMIZED accordingly // Manually detect if the window was maximized (due to SDL2 restore being unreliable on some platforms) to remove the FLAG_WINDOW_MAXIMIZED accordingly
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED))
{ {
int borderTop = 0; int borderTop = 0;
int borderLeft = 0; int borderLeft = 0;
@ -1482,43 +1482,43 @@ void PollInputEvents(void)
case SDL_WINDOWEVENT_MINIMIZED: case SDL_WINDOWEVENT_MINIMIZED:
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) == 0) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);
} break; } break;
case SDL_WINDOWEVENT_MAXIMIZED: case SDL_WINDOWEVENT_MAXIMIZED:
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) == 0) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);
} break; } break;
case SDL_WINDOWEVENT_RESTORED: case SDL_WINDOWEVENT_RESTORED:
{ {
if (FLAG_CHECK(SDL_GetWindowFlags(platform.window), SDL_WINDOW_MINIMIZED) == 0) if (!FLAG_IS_SET(SDL_GetWindowFlags(platform.window), SDL_WINDOW_MINIMIZED))
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);
} }
#ifdef USING_VERSION_SDL3 #ifdef USING_VERSION_SDL3
if (FLAG_CHECK(SDL_GetWindowFlags(platform.window), SDL_WINDOW_MAXIMIZED) == 0) if (!FLAG_IS_SET(SDL_GetWindowFlags(platform.window), SDL_WINDOW_MAXIMIZED))
{ {
if (FLAG_CHECK(CORE.Window.flags, SDL_WINDOW_MAXIMIZED) > 0) FLAG_CLEAR(CORE.Window.flags, SDL_WINDOW_MAXIMIZED); if (FLAG_IS_SET(CORE.Window.flags, SDL_WINDOW_MAXIMIZED)) FLAG_CLEAR(CORE.Window.flags, SDL_WINDOW_MAXIMIZED);
} }
#endif #endif
} break; } break;
case SDL_WINDOWEVENT_HIDDEN: case SDL_WINDOWEVENT_HIDDEN:
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) == 0) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN);
} break; } break;
case SDL_WINDOWEVENT_SHOWN: case SDL_WINDOWEVENT_SHOWN:
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_HIDDEN); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_HIDDEN);
} break; } break;
case SDL_WINDOWEVENT_FOCUS_GAINED: case SDL_WINDOWEVENT_FOCUS_GAINED:
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED);
} break; } break;
case SDL_WINDOWEVENT_FOCUS_LOST: case SDL_WINDOWEVENT_FOCUS_LOST:
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) == 0) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED); if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) FLAG_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED);
} break; } break;
#ifndef USING_VERSION_SDL3 #ifndef USING_VERSION_SDL3
@ -1894,28 +1894,28 @@ int InitPlatform(void)
FLAG_SET(flags, SDL_WINDOW_MOUSE_CAPTURE); // Window has mouse captured FLAG_SET(flags, SDL_WINDOW_MOUSE_CAPTURE); // Window has mouse captured
// Check window creation flags // Check window creation flags
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE))
{ {
CORE.Window.fullscreen = true; CORE.Window.fullscreen = true;
FLAG_SET(flags, SDL_WINDOW_FULLSCREEN); FLAG_SET(flags, SDL_WINDOW_FULLSCREEN);
} }
//if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) == 0) FLAG_SET(flags, SDL_WINDOW_HIDDEN); //if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) FLAG_SET(flags, SDL_WINDOW_HIDDEN);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) > 0) FLAG_SET(flags, SDL_WINDOW_BORDERLESS); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) FLAG_SET(flags, SDL_WINDOW_BORDERLESS);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) > 0) FLAG_SET(flags, SDL_WINDOW_RESIZABLE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) FLAG_SET(flags, SDL_WINDOW_RESIZABLE);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) > 0) FLAG_SET(flags, SDL_WINDOW_MINIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) FLAG_SET(flags, SDL_WINDOW_MINIMIZED);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) > 0) FLAG_SET(flags, SDL_WINDOW_MAXIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_SET(flags, SDL_WINDOW_MAXIMIZED);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED))
{ {
FLAG_CLEAR(flags, SDL_WINDOW_INPUT_FOCUS); FLAG_CLEAR(flags, SDL_WINDOW_INPUT_FOCUS);
FLAG_CLEAR(flags, SDL_WINDOW_MOUSE_FOCUS); FLAG_CLEAR(flags, SDL_WINDOW_MOUSE_FOCUS);
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TOPMOST) > 0) FLAG_SET(flags, SDL_WINDOW_ALWAYS_ON_TOP); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST)) FLAG_SET(flags, SDL_WINDOW_ALWAYS_ON_TOP);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) FLAG_CLEAR(flags, SDL_WINDOW_MOUSE_CAPTURE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MOUSE_PASSTHROUGH)) FLAG_CLEAR(flags, SDL_WINDOW_MOUSE_CAPTURE);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) FLAG_SET(flags, SDL_WINDOW_ALLOW_HIGHDPI); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)) FLAG_SET(flags, SDL_WINDOW_ALLOW_HIGHDPI);
//if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT) > 0) FLAG_SET(flags, SDL_WINDOW_TRANSPARENT); // Alternative: SDL_GL_ALPHA_SIZE = 8 //if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TRANSPARENT)) FLAG_SET(flags, SDL_WINDOW_TRANSPARENT); // Alternative: SDL_GL_ALPHA_SIZE = 8
//if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_DESKTOP) > 0) FLAG_SET(flags, SDL_WINDOW_FULLSCREEN_DESKTOP); //if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_DESKTOP)) FLAG_SET(flags, SDL_WINDOW_FULLSCREEN_DESKTOP);
// NOTE: Some OpenGL context attributes must be set before window creation // NOTE: Some OpenGL context attributes must be set before window creation
@ -1958,7 +1958,7 @@ int InitPlatform(void)
SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0); SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 0);
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1);
SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4); SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 4);
@ -2001,7 +2001,7 @@ int InitPlatform(void)
if (platform.glContext != NULL) if (platform.glContext != NULL)
{ {
SDL_GL_SetSwapInterval((FLAG_CHECK(CORE.Window.flags, FLAG_VSYNC_HINT) > 0)? 1 : 0); SDL_GL_SetSwapInterval((FLAG_IS_SET(CORE.Window.flags, FLAG_VSYNC_HINT))? 1: 0);
// Load OpenGL extensions // Load OpenGL extensions
// NOTE: GL procedures address loader is required to load extensions // NOTE: GL procedures address loader is required to load extensions

18
src/platforms/rcore_drm.c
View File

@ -1313,7 +1313,7 @@ int InitPlatform(void)
CORE.Window.screen.height = CORE.Window.display.height; CORE.Window.screen.height = CORE.Window.display.height;
} }
const bool allowInterlaced = FLAG_CHECK(CORE.Window.flags. FLAG_INTERLACED_HINT); const bool allowInterlaced = FLAG_IS_SET(CORE.Window.flags. FLAG_INTERLACED_HINT);
const int fps = (CORE.Time.target > 0) ? (1.0/CORE.Time.target) : 60; const int fps = (CORE.Time.target > 0) ? (1.0/CORE.Time.target) : 60;
// Try to find an exact matching mode // Try to find an exact matching mode
@ -1344,7 +1344,7 @@ int InitPlatform(void)
TRACELOG(LOG_INFO, "DISPLAY: Selected DRM connector mode %s (%ux%u%c@%u)", platform.connector->modes[platform.modeIndex].name, TRACELOG(LOG_INFO, "DISPLAY: Selected DRM connector mode %s (%ux%u%c@%u)", platform.connector->modes[platform.modeIndex].name,
platform.connector->modes[platform.modeIndex].hdisplay, platform.connector->modes[platform.modeIndex].vdisplay, platform.connector->modes[platform.modeIndex].hdisplay, platform.connector->modes[platform.modeIndex].vdisplay,
FLAG_CHECK(platform.connector->modes[platform.modeIndex].flags, DRM_MODE_FLAG_INTERLACE)? 'i' : 'p', FLAG_IS_SET(platform.connector->modes[platform.modeIndex].flags, DRM_MODE_FLAG_INTERLACE)? 'i' : 'p',
platform.connector->modes[platform.modeIndex].vrefresh); platform.connector->modes[platform.modeIndex].vrefresh);
drmModeFreeEncoder(enc); drmModeFreeEncoder(enc);
@ -1400,7 +1400,7 @@ int InitPlatform(void)
EGLint samples = 0; EGLint samples = 0;
EGLint sampleBuffer = 0; EGLint sampleBuffer = 0;
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
samples = 4; samples = 4;
sampleBuffer = 1; sampleBuffer = 1;
@ -1577,7 +1577,7 @@ int InitPlatform(void)
TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y); TRACELOG(LOG_INFO, " > Viewport offsets: %i, %i", CORE.Window.renderOffset.x, CORE.Window.renderOffset.y);
#endif #endif
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow(); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) MinimizeWindow();
// If graphic device is no properly initialized, we end program // If graphic device is no properly initialized, we end program
if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; } if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; }
@ -2416,7 +2416,7 @@ static int FindMatchingConnectorMode(const drmModeConnector *connector, const dr
for (size_t i = 0; i < connector->count_modes; i++) for (size_t i = 0; i < connector->count_modes; i++)
{ {
TRACELOG(LOG_TRACE, "DISPLAY: DRM mode: %d %ux%u@%u %s", i, connector->modes[i].hdisplay, connector->modes[i].vdisplay, TRACELOG(LOG_TRACE, "DISPLAY: DRM mode: %d %ux%u@%u %s", i, connector->modes[i].hdisplay, connector->modes[i].vdisplay,
connector->modes[i].vrefresh, (FLAG_CHECK(connector->modes[i].flags, DRM_MODE_FLAG_INTERLACE) > 0)? "interlaced" : "progressive"); connector->modes[i].vrefresh, (FLAG_IS_SET(connector->modes[i].flags, DRM_MODE_FLAG_INTERLACE) > 0)? "interlaced" : "progressive");
if (0 == BINCMP(&platform.crtc->mode, &platform.connector->modes[i])) return i; if (0 == BINCMP(&platform.crtc->mode, &platform.connector->modes[i])) return i;
} }
@ -2437,9 +2437,9 @@ static int FindExactConnectorMode(const drmModeConnector *connector, uint width,
{ {
const drmModeModeInfo *const mode = &platform.connector->modes[i]; const drmModeModeInfo *const mode = &platform.connector->modes[i];
TRACELOG(LOG_TRACE, "DISPLAY: DRM Mode %d %ux%u@%u %s", i, mode->hdisplay, mode->vdisplay, mode->vrefresh, (FLAG_CHECK(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0)? "interlaced" : "progressive"); TRACELOG(LOG_TRACE, "DISPLAY: DRM Mode %d %ux%u@%u %s", i, mode->hdisplay, mode->vdisplay, mode->vrefresh, (FLAG_IS_SET(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0)? "interlaced" : "progressive");
if ((FLAG_CHECK(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0) && !allowInterlaced) continue; if ((FLAG_IS_SET(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0) && !allowInterlaced) continue;
if ((mode->hdisplay == width) && (mode->vdisplay == height) && (mode->vrefresh == fps)) return i; if ((mode->hdisplay == width) && (mode->vdisplay == height) && (mode->vrefresh == fps)) return i;
} }
@ -2463,7 +2463,7 @@ static int FindNearestConnectorMode(const drmModeConnector *connector, uint widt
const drmModeModeInfo *const mode = &platform.connector->modes[i]; const drmModeModeInfo *const mode = &platform.connector->modes[i];
TRACELOG(LOG_TRACE, "DISPLAY: DRM mode: %d %ux%u@%u %s", i, mode->hdisplay, mode->vdisplay, mode->vrefresh, TRACELOG(LOG_TRACE, "DISPLAY: DRM mode: %d %ux%u@%u %s", i, mode->hdisplay, mode->vdisplay, mode->vrefresh,
(FLAG_CHECK(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0)? "interlaced" : "progressive"); (FLAG_IS_SET(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0)? "interlaced" : "progressive");
if ((mode->hdisplay < width) || (mode->vdisplay < height)) if ((mode->hdisplay < width) || (mode->vdisplay < height))
{ {
@ -2471,7 +2471,7 @@ static int FindNearestConnectorMode(const drmModeConnector *connector, uint widt
continue; continue;
} }
if ((FLAG_CHECK(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0) && !allowInterlaced) if ((FLAG_IS_SET(mode->flags, DRM_MODE_FLAG_INTERLACE) > 0) && !allowInterlaced)
{ {
TRACELOG(LOG_TRACE, "DISPLAY: DRM shouldn't choose an interlaced mode"); TRACELOG(LOG_TRACE, "DISPLAY: DRM shouldn't choose an interlaced mode");
continue; continue;

2
src/platforms/rcore_template.c
View File

@ -464,7 +464,7 @@ int InitPlatform(void)
EGLint samples = 0; EGLint samples = 0;
EGLint sampleBuffer = 0; EGLint sampleBuffer = 0;
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
samples = 4; samples = 4;
sampleBuffer = 1; sampleBuffer = 1;

116
src/platforms/rcore_web.c
View File

@ -181,8 +181,8 @@ void ToggleFullscreen(void)
const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0); const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0);
if (wasFullscreen) if (wasFullscreen)
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE > 0)) enterFullscreen = false; if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) enterFullscreen = false;
else if (FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE > 0)) enterFullscreen = true; else if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE)) enterFullscreen = true;
else else
{ {
const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0); const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0);
@ -289,8 +289,8 @@ void ToggleBorderlessWindowed(void)
const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0); const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0);
if (wasFullscreen) if (wasFullscreen)
{ {
if (FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE > 0)) enterBorderless = false; if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE)) enterBorderless = false;
else if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) enterBorderless = true; else if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) enterBorderless = true;
else else
{ {
const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0); const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0);
@ -329,7 +329,7 @@ void ToggleBorderlessWindowed(void)
// Set window state: maximized, if resizable // Set window state: maximized, if resizable
void MaximizeWindow(void) void MaximizeWindow(void)
{ {
if ((glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE) && !(FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0)) if ((glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE) && !(FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)))
{ {
platform.unmaximizedWidth = CORE.Window.screen.width; platform.unmaximizedWidth = CORE.Window.screen.width;
platform.unmaximizedHeight = CORE.Window.screen.height; platform.unmaximizedHeight = CORE.Window.screen.height;
@ -352,7 +352,7 @@ void MinimizeWindow(void)
// Restore window from being minimized/maximized // Restore window from being minimized/maximized
void RestoreWindow(void) void RestoreWindow(void)
{ {
if ((glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE) && (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0)) if ((glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE) && (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)))
{ {
if (platform.unmaximizedWidth && platform.unmaximizedHeight) glfwSetWindowSize(platform.handle, platform.unmaximizedWidth, platform.unmaximizedHeight); if (platform.unmaximizedWidth && platform.unmaximizedHeight) glfwSetWindowSize(platform.handle, platform.unmaximizedWidth, platform.unmaximizedHeight);
@ -369,13 +369,13 @@ void SetWindowState(unsigned int flags)
// NOTE: In most cases the functions already change the flags internally // NOTE: In most cases the functions already change the flags internally
// State change: FLAG_VSYNC_HINT // State change: FLAG_VSYNC_HINT
if (FLAG_CHECK(flags, FLAG_VSYNC_HINT)) if (FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_VSYNC_HINT) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_VSYNC_HINT) not available on target platform");
} }
// State change: FLAG_BORDERLESS_WINDOWED_MODE // State change: FLAG_BORDERLESS_WINDOWED_MODE
if (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE)) if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
// NOTE: Window state flag updated inside ToggleBorderlessWindowed() function // NOTE: Window state flag updated inside ToggleBorderlessWindowed() function
const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0); const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0);
@ -383,13 +383,13 @@ void SetWindowState(unsigned int flags)
{ {
const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0); const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0);
const int canvasStyleWidth = EM_ASM_INT( { return parseInt(Module.canvas.style.width); }, 0); const int canvasStyleWidth = EM_ASM_INT( { return parseInt(Module.canvas.style.width); }, 0);
if ((FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) || canvasStyleWidth > canvasWidth) ToggleBorderlessWindowed(); if ((FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) || canvasStyleWidth > canvasWidth) ToggleBorderlessWindowed();
} }
else ToggleBorderlessWindowed(); else ToggleBorderlessWindowed();
} }
// State change: FLAG_FULLSCREEN_MODE // State change: FLAG_FULLSCREEN_MODE
if (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE) > 0) if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
// NOTE: Window state flag updated inside ToggleFullscreen() function // NOTE: Window state flag updated inside ToggleFullscreen() function
const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0); const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0);
@ -397,38 +397,38 @@ void SetWindowState(unsigned int flags)
{ {
const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0); const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0);
const int screenWidth = EM_ASM_INT( { return screen.width; }, 0); const int screenWidth = EM_ASM_INT( { return screen.width; }, 0);
if ((FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0) || screenWidth == canvasWidth ) ToggleFullscreen(); if ((FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE)) || screenWidth == canvasWidth ) ToggleFullscreen();
} }
else ToggleFullscreen(); else ToggleFullscreen();
} }
// State change: FLAG_WINDOW_RESIZABLE // State change: FLAG_WINDOW_RESIZABLE
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE)) && (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE)) && (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_TRUE); glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_TRUE);
FLAG_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE); FLAG_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE);
} }
// State change: FLAG_WINDOW_UNDECORATED // State change: FLAG_WINDOW_UNDECORATED
if (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_UNDECORATED) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_UNDECORATED) not available on target platform");
} }
// State change: FLAG_WINDOW_HIDDEN // State change: FLAG_WINDOW_HIDDEN
if (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_HIDDEN) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_HIDDEN) not available on target platform");
} }
// State change: FLAG_WINDOW_MINIMIZED // State change: FLAG_WINDOW_MINIMIZED
if (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_MINIMIZED) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_MINIMIZED) not available on target platform");
} }
// State change: FLAG_WINDOW_MAXIMIZED // State change: FLAG_WINDOW_MAXIMIZED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) != FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED)) && (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) != FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED)) && (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED)))
{ {
if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE) if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE)
{ {
@ -445,19 +445,19 @@ void SetWindowState(unsigned int flags)
} }
// State change: FLAG_WINDOW_UNFOCUSED // State change: FLAG_WINDOW_UNFOCUSED
if (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_UNFOCUSED) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_UNFOCUSED) not available on target platform");
} }
// State change: FLAG_WINDOW_TOPMOST // State change: FLAG_WINDOW_TOPMOST
if (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_TOPMOST) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_TOPMOST) not available on target platform");
} }
// State change: FLAG_WINDOW_ALWAYS_RUN // State change: FLAG_WINDOW_ALWAYS_RUN
if (FLAG_CHECK(flags, FLAG_WINDOW_ALWAYS_RUN) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_ALWAYS_RUN))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_ALWAYS_RUN) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_ALWAYS_RUN) not available on target platform");
} }
@ -466,31 +466,31 @@ void SetWindowState(unsigned int flags)
// NOTE: Review for PLATFORM_WEB // NOTE: Review for PLATFORM_WEB
// State change: FLAG_WINDOW_TRANSPARENT // State change: FLAG_WINDOW_TRANSPARENT
if (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_TRANSPARENT) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_TRANSPARENT) not available on target platform");
} }
// State change: FLAG_WINDOW_HIGHDPI // State change: FLAG_WINDOW_HIGHDPI
if (FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_HIGHDPI) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_HIGHDPI) not available on target platform");
} }
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH // State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
if (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_MOUSE_PASSTHROUGH) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_WINDOW_MOUSE_PASSTHROUGH) not available on target platform");
} }
// State change: FLAG_MSAA_4X_HINT // State change: FLAG_MSAA_4X_HINT
if (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_MSAA_4X_HINT) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_MSAA_4X_HINT) not available on target platform");
} }
// State change: FLAG_INTERLACED_HINT // State change: FLAG_INTERLACED_HINT
if (FLAG_CHECK(flags, FLAG_INTERLACED_HINT) > 0) if (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "SetWindowState(FLAG_INTERLACED_HINT) not available on target platform"); TRACELOG(LOG_WARNING, "SetWindowState(FLAG_INTERLACED_HINT) not available on target platform");
} }
@ -503,34 +503,34 @@ void ClearWindowState(unsigned int flags)
// NOTE: In most cases the functions already change the flags internally // NOTE: In most cases the functions already change the flags internally
// State change: FLAG_VSYNC_HINT // State change: FLAG_VSYNC_HINT
if (FLAG_CHECK(flags, FLAG_VSYNC_HINT) > 0) if (FLAG_IS_SET(flags, FLAG_VSYNC_HINT))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_VSYNC_HINT) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_VSYNC_HINT) not available on target platform");
} }
// State change: FLAG_BORDERLESS_WINDOWED_MODE // State change: FLAG_BORDERLESS_WINDOWED_MODE
if (FLAG_CHECK(flags, FLAG_BORDERLESS_WINDOWED_MODE) > 0) if (FLAG_IS_SET(flags, FLAG_BORDERLESS_WINDOWED_MODE))
{ {
const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0); const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0);
if (wasFullscreen) if (wasFullscreen)
{ {
const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0); const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0);
const int screenWidth = EM_ASM_INT( { return screen.width; }, 0); const int screenWidth = EM_ASM_INT( { return screen.width; }, 0);
if (FLAG_CHECK(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) || (screenWidth == canvasWidth)) EM_ASM(document.exitFullscreen();); if (FLAG_IS_SET(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE) || (screenWidth == canvasWidth)) EM_ASM(document.exitFullscreen(););
} }
FLAG_CLEAR(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE); FLAG_CLEAR(CORE.Window.flags, FLAG_BORDERLESS_WINDOWED_MODE);
} }
// State change: FLAG_FULLSCREEN_MODE // State change: FLAG_FULLSCREEN_MODE
if (FLAG_CHECK(flags, FLAG_FULLSCREEN_MODE) > 0) if (FLAG_IS_SET(flags, FLAG_FULLSCREEN_MODE))
{ {
const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0); const bool wasFullscreen = EM_ASM_INT( { if (document.fullscreenElement) return 1; }, 0);
if (wasFullscreen) if (wasFullscreen)
{ {
const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0); const int canvasWidth = EM_ASM_INT( { return Module.canvas.width; }, 0);
const int canvasStyleWidth = EM_ASM_INT( { return parseInt(Module.canvas.style.width); }, 0); const int canvasStyleWidth = EM_ASM_INT( { return parseInt(Module.canvas.style.width); }, 0);
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) || (canvasStyleWidth > canvasWidth)) EM_ASM(document.exitFullscreen();); if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE) || (canvasStyleWidth > canvasWidth)) EM_ASM(document.exitFullscreen(););
} }
CORE.Window.fullscreen = false; CORE.Window.fullscreen = false;
@ -538,26 +538,26 @@ void ClearWindowState(unsigned int flags)
} }
// State change: FLAG_WINDOW_RESIZABLE // State change: FLAG_WINDOW_RESIZABLE
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_RESIZABLE) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) && (FLAG_IS_SET(flags, FLAG_WINDOW_RESIZABLE)))
{ {
glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_FALSE); glfwSetWindowAttrib(platform.handle, GLFW_RESIZABLE, GLFW_FALSE);
FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_RESIZABLE); FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_RESIZABLE);
} }
// State change: FLAG_WINDOW_HIDDEN // State change: FLAG_WINDOW_HIDDEN
if (FLAG_CHECK(flags, FLAG_WINDOW_HIDDEN) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIDDEN))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_HIDDEN) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_HIDDEN) not available on target platform");
} }
// State change: FLAG_WINDOW_MINIMIZED // State change: FLAG_WINDOW_MINIMIZED
if (FLAG_CHECK(flags, FLAG_WINDOW_MINIMIZED) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_MINIMIZED))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_MINIMIZED) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_MINIMIZED) not available on target platform");
} }
// State change: FLAG_WINDOW_MAXIMIZED // State change: FLAG_WINDOW_MAXIMIZED
if ((FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0) && (FLAG_CHECK(flags, FLAG_WINDOW_MAXIMIZED) > 0)) if ((FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) && (FLAG_IS_SET(flags, FLAG_WINDOW_MAXIMIZED)))
{ {
if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE) if (glfwGetWindowAttrib(platform.handle, GLFW_RESIZABLE) == GLFW_TRUE)
{ {
@ -568,25 +568,25 @@ void ClearWindowState(unsigned int flags)
} }
// State change: FLAG_WINDOW_UNDECORATED // State change: FLAG_WINDOW_UNDECORATED
if (FLAG_CHECK(flags, FLAG_WINDOW_UNDECORATED) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNDECORATED))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_UNDECORATED) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_UNDECORATED) not available on target platform");
} }
// State change: FLAG_WINDOW_UNFOCUSED // State change: FLAG_WINDOW_UNFOCUSED
if (FLAG_CHECK(flags, FLAG_WINDOW_UNFOCUSED) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_UNFOCUSED))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_UNFOCUSED) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_UNFOCUSED) not available on target platform");
} }
// State change: FLAG_WINDOW_TOPMOST // State change: FLAG_WINDOW_TOPMOST
if (FLAG_CHECK(flags, FLAG_WINDOW_TOPMOST) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_TOPMOST))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_TOPMOST) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_TOPMOST) not available on target platform");
} }
// State change: FLAG_WINDOW_ALWAYS_RUN // State change: FLAG_WINDOW_ALWAYS_RUN
if (FLAG_CHECK(flags, FLAG_WINDOW_ALWAYS_RUN) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_ALWAYS_RUN))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_ALWAYS_RUN) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_ALWAYS_RUN) not available on target platform");
} }
@ -595,31 +595,31 @@ void ClearWindowState(unsigned int flags)
// NOTE: Review for PLATFORM_WEB // NOTE: Review for PLATFORM_WEB
// State change: FLAG_WINDOW_TRANSPARENT // State change: FLAG_WINDOW_TRANSPARENT
if (FLAG_CHECK(flags, FLAG_WINDOW_TRANSPARENT) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_TRANSPARENT))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_TRANSPARENT) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_TRANSPARENT) not available on target platform");
} }
// State change: FLAG_WINDOW_HIGHDPI // State change: FLAG_WINDOW_HIGHDPI
if (FLAG_CHECK(flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_HIGHDPI))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_HIGHDPI) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_HIGHDPI) not available on target platform");
} }
// State change: FLAG_WINDOW_MOUSE_PASSTHROUGH // State change: FLAG_WINDOW_MOUSE_PASSTHROUGH
if (FLAG_CHECK(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH) > 0) if (FLAG_IS_SET(flags, FLAG_WINDOW_MOUSE_PASSTHROUGH))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_MOUSE_PASSTHROUGH) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_WINDOW_MOUSE_PASSTHROUGH) not available on target platform");
} }
// State change: FLAG_MSAA_4X_HINT // State change: FLAG_MSAA_4X_HINT
if (FLAG_CHECK(flags, FLAG_MSAA_4X_HINT) > 0) if (FLAG_IS_SET(flags, FLAG_MSAA_4X_HINT))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_MSAA_4X_HINT) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_MSAA_4X_HINT) not available on target platform");
} }
// State change: FLAG_INTERLACED_HINT // State change: FLAG_INTERLACED_HINT
if (FLAG_CHECK(flags, FLAG_INTERLACED_HINT) > 0) if (FLAG_IS_SET(flags, FLAG_INTERLACED_HINT))
{ {
TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_INTERLACED_HINT) not available on target platform"); TRACELOG(LOG_WARNING, "ClearWindowState(FLAG_INTERLACED_HINT) not available on target platform");
} }
@ -663,7 +663,7 @@ void SetWindowMinSize(int width, int height)
CORE.Window.screenMin.height = height; CORE.Window.screenMin.height = height;
// Trigger the resize event once to update the window minimum width and height // Trigger the resize event once to update the window minimum width and height
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != 0) EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != 0) EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL);
} }
// Set window maximum dimensions (FLAG_WINDOW_RESIZABLE) // Set window maximum dimensions (FLAG_WINDOW_RESIZABLE)
@ -673,7 +673,7 @@ void SetWindowMaxSize(int width, int height)
CORE.Window.screenMax.height = height; CORE.Window.screenMax.height = height;
// Trigger the resize event once to update the window maximum width and height // Trigger the resize event once to update the window maximum width and height
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != 0) EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) != 0) EmscriptenResizeCallback(EMSCRIPTEN_EVENT_RESIZE, NULL, NULL);
} }
// Set window dimensions // Set window dimensions
@ -1122,27 +1122,27 @@ int InitPlatform(void)
// glfwWindowHint(GLFW_AUX_BUFFERS, 0); // Number of auxiliar buffers // glfwWindowHint(GLFW_AUX_BUFFERS, 0); // Number of auxiliar buffers
// Check window creation flags // Check window creation flags
if (FLAG_CHECK(CORE.Window.flags, FLAG_FULLSCREEN_MODE) > 0) CORE.Window.fullscreen = true; if (FLAG_IS_SET(CORE.Window.flags, FLAG_FULLSCREEN_MODE)) CORE.Window.fullscreen = true;
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) > 0) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN)) glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); // Visible window
else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden else glfwWindowHint(GLFW_VISIBLE, GLFW_TRUE); // Window initially hidden
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNDECORATED) > 0) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNDECORATED)) glfwWindowHint(GLFW_DECORATED, GLFW_FALSE); // Border and buttons on Window
else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window else glfwWindowHint(GLFW_DECORATED, GLFW_TRUE); // Decorated window
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) > 0) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) glfwWindowHint(GLFW_RESIZABLE, GLFW_TRUE); // Resizable window
else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable else glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE); // Avoid window being resizable
// Disable FLAG_WINDOW_MINIMIZED, not supported on initialization // Disable FLAG_WINDOW_MINIMIZED, not supported on initialization
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MINIMIZED);
// Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization // Disable FLAG_WINDOW_MAXIMIZED, not supported on initialization
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED)) FLAG_CLEAR(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) > 0) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED)) glfwWindowHint(GLFW_FOCUSED, GLFW_FALSE);
else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE); else glfwWindowHint(GLFW_FOCUSED, GLFW_TRUE);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_TOPMOST) > 0) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_TOPMOST)) glfwWindowHint(GLFW_FLOATING, GLFW_TRUE);
else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE); else glfwWindowHint(GLFW_FLOATING, GLFW_FALSE);
// NOTE: Some GLFW flags are not supported on HTML5 // NOTE: Some GLFW flags are not supported on HTML5
@ -1150,10 +1150,10 @@ int InitPlatform(void)
// Scale content area based on the monitor content scale where window is placed on // Scale content area based on the monitor content scale where window is placed on
// NOTE: This feature requires emscripten 3.1.51 // NOTE: This feature requires emscripten 3.1.51
//if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE); //if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)) glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_TRUE);
//else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE); //else glfwWindowHint(GLFW_SCALE_TO_MONITOR, GLFW_FALSE);
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
// NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs // NOTE: MSAA is only enabled for main framebuffer, not user-created FBOs
TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4"); TRACELOG(LOG_INFO, "DISPLAY: Trying to enable MSAA x4");
@ -1296,7 +1296,7 @@ int InitPlatform(void)
glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback); glfwSetWindowFocusCallback(platform.handle, WindowFocusCallback);
glfwSetDropCallback(platform.handle, WindowDropCallback); glfwSetDropCallback(platform.handle, WindowDropCallback);
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
// Window content (framebuffer) scale callback // Window content (framebuffer) scale callback
glfwSetWindowContentScaleCallback(platform.handle, WindowContentScaleCallback); glfwSetWindowContentScaleCallback(platform.handle, WindowContentScaleCallback);
@ -1338,7 +1338,7 @@ int InitPlatform(void)
return -1; return -1;
} }
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0) MinimizeWindow(); if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED)) MinimizeWindow();
// If graphic device is no properly initialized, we end program // If graphic device is no properly initialized, we end program
if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; } if (!CORE.Window.ready) { TRACELOG(LOG_FATAL, "PLATFORM: Failed to initialize graphic device"); return -1; }
@ -1423,7 +1423,7 @@ static void WindowSizeCallback(GLFWwindow *window, int width, int height)
if (IsWindowFullscreen()) return; if (IsWindowFullscreen()) return;
// Set current screen size // Set current screen size
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0) if (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI))
{ {
Vector2 windowScaleDPI = GetWindowScaleDPI(); Vector2 windowScaleDPI = GetWindowScaleDPI();
@ -1794,7 +1794,7 @@ static EM_BOOL EmscriptenFullscreenChangeCallback(int eventType, const Emscripte
static EM_BOOL EmscriptenResizeCallback(int eventType, const EmscriptenUiEvent *event, void *userData) static EM_BOOL EmscriptenResizeCallback(int eventType, const EmscriptenUiEvent *event, void *userData)
{ {
// Don't resize non-resizeable windows // Don't resize non-resizeable windows
if (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_RESIZABLE) == 0) return 1; if (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_RESIZABLE)) return 1;
// This event is called whenever the window changes sizes, // This event is called whenever the window changes sizes,
// so the size of the canvas object is explicitly retrieved below // so the size of the canvas object is explicitly retrieved below

16
src/rcore.c
View File

@ -272,7 +272,7 @@ __declspec(dllimport) unsigned int __stdcall timeEndPeriod(unsigned int uPeriod)
#define FLAG_SET(n, f) ((n) |= (f)) #define FLAG_SET(n, f) ((n) |= (f))
#define FLAG_CLEAR(n, f) ((n) &= ~(f)) #define FLAG_CLEAR(n, f) ((n) &= ~(f))
#define FLAG_TOGGLE(n, f) ((n) ^= (f)) #define FLAG_TOGGLE(n, f) ((n) ^= (f))
#define FLAG_CHECK(n, f) ((n) & (f)) #define FLAG_IS_SET(n, f) (((n) & (f)) > 0)
//---------------------------------------------------------------------------------- //----------------------------------------------------------------------------------
// Types and Structures Definition // Types and Structures Definition
@ -714,7 +714,7 @@ void InitWindow(int width, int height, const char *title)
// Set font white rectangle for shapes drawing, so shapes and text can be batched together // 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 // WARNING: rshapes module is required, if not available, default internal white rectangle is used
Rectangle rec = GetFontDefault().recs[95]; Rectangle rec = GetFontDefault().recs[95];
if (FLAG_CHECK(CORE.Window.flags, FLAG_MSAA_4X_HINT)) if (FLAG_IS_SET(CORE.Window.flags, FLAG_MSAA_4X_HINT))
{ {
// NOTE: We try to maxime rec padding to avoid pixel bleeding on MSAA filtering // 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 }); SetShapesTexture(GetFontDefault().texture, (Rectangle){ rec.x + 2, rec.y + 2, 1, 1 });
@ -786,25 +786,25 @@ bool IsWindowFullscreen(void)
// Check if window is currently hidden // Check if window is currently hidden
bool IsWindowHidden(void) bool IsWindowHidden(void)
{ {
return (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIDDEN) > 0); return (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIDDEN));
} }
// Check if window has been minimized // Check if window has been minimized
bool IsWindowMinimized(void) bool IsWindowMinimized(void)
{ {
return (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MINIMIZED) > 0); return (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MINIMIZED));
} }
// Check if window has been maximized // Check if window has been maximized
bool IsWindowMaximized(void) bool IsWindowMaximized(void)
{ {
return (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED) > 0); return (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_MAXIMIZED));
} }
// Check if window has the focus // Check if window has the focus
bool IsWindowFocused(void) bool IsWindowFocused(void)
{ {
return (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED) == 0); return (!FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_UNFOCUSED));
} }
// Check if window has been resizedLastFrame // Check if window has been resizedLastFrame
@ -816,7 +816,7 @@ bool IsWindowResized(void)
// Check if one specific window flag is enabled // Check if one specific window flag is enabled
bool IsWindowState(unsigned int flag) bool IsWindowState(unsigned int flag)
{ {
return (FLAG_CHECK(CORE.Window.flags, flag) > 0); return (FLAG_IS_SET(CORE.Window.flags, flag));
} }
// Get current screen width // Get current screen width
@ -1197,7 +1197,7 @@ void BeginScissorMode(int x, int y, int width, int height)
rlScissor((int)(x*scale.x), (int)(GetScreenHeight()*scale.y - (((y + height)*scale.y))), (int)(width*scale.x), (int)(height*scale.y)); rlScissor((int)(x*scale.x), (int)(GetScreenHeight()*scale.y - (((y + height)*scale.y))), (int)(width*scale.x), (int)(height*scale.y));
} }
#else #else
if (!CORE.Window.usingFbo && (FLAG_CHECK(CORE.Window.flags, FLAG_WINDOW_HIGHDPI) > 0)) if (!CORE.Window.usingFbo && (FLAG_IS_SET(CORE.Window.flags, FLAG_WINDOW_HIGHDPI)))
{ {
Vector2 scale = GetWindowScaleDPI(); Vector2 scale = GetWindowScaleDPI();
rlScissor((int)(x*scale.x), (int)(CORE.Window.currentFbo.height - (y + height)*scale.y), (int)(width*scale.x), (int)(height*scale.y)); rlScissor((int)(x*scale.x), (int)(CORE.Window.currentFbo.height - (y + height)*scale.y), (int)(width*scale.x), (int)(height*scale.y));